a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
221}
222
223mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
228}
229
231{
232 return myNPbase->mueeZllH(sqrt_s);
233}
234
235mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
240}
241
243{
245}
246
247mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
252}
253
255{
256 return myNPbase->mueeZqqH(sqrt_s);
257}
258
259mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
264}
265
267{
269}
270
271
272aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
273: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
274{
275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
276 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
277}
278
280{
282}
283
284
285bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
287{
288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
289 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
290}
291
293{
295}
296
297
298muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
300{
301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
302 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
303}
304
306{
307 return myNPbase->muVH(sqrt_s);
308}
309
310muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVHpT250(sqrt_s);
320}
321
322muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVBFpVH(sqrt_s);
332}
333
334muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muttH(sqrt_s);
344}
345
346mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->mutHq(sqrt_s);
356}
357
358muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->muggHpttH(sqrt_s);
368}
369
370mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
375
376}
377
379{
380 return myNPbase->mueettH(sqrt_s);
381}
382
383mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
385{
386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
387 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
388}
389
391{
393}
394
395mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
400}
401
403{
404 return myNPbase->mummH(sqrt_s);
405}
406
407mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummHNWA(sqrt_s);
417}
418
419// -----------------------------------------------------------------------------
420// Decay widths
421// -----------------------------------------------------------------------------
422
424: ThObservable(SM_i)
425{
426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
427 throw std::runtime_error("GammaHtoggRatio called with a class whose parent is not NPbase");
428}
429
431{
432 return myNPbase->GammaHggRatio();
433}
434
436: ThObservable(SM_i)
437{
438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
439 throw std::runtime_error("GammaHtoWWRatio called with a class whose parent is not NPbase");
440}
441
443{
444 return myNPbase->GammaHWWRatio();
445}
446
448: ThObservable(SM_i)
449{
450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
451 throw std::runtime_error("GammaHtoZZRatio called with a class whose parent is not NPbase");
452}
453
455{
456 return myNPbase->GammaHZZRatio();
457}
458
460{
461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
462 throw std::runtime_error("GammaHtoZgaRatio called with a class whose parent is not NPbase");
463}
464
466{
467 return myNPbase->GammaHZgaRatio();
468}
469
471{
472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
473 throw std::runtime_error("GammaHtogagaRatio called with a class whose parent is not NPbase");
474}
475
477{
478 return myNPbase->GammaHgagaRatio();
479}
480
482{
483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
484 throw std::runtime_error("GammaHtomumuRatio called with a class whose parent is not NPbase");
485}
486
488{
489 return myNPbase->GammaHmumuRatio();
490}
491
493{
494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
495 throw std::runtime_error("GammaHtotautauRatio called with a class whose parent is not NPbase");
496}
497
499{
500 return myNPbase->GammaHtautauRatio();
501}
502
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("GammaHtossRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->GammaHssRatio();
512}
513
515{
516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
517 throw std::runtime_error("GammaHtoccRatio called with a class whose parent is not NPbase");
518}
519
521{
522 return myNPbase->GammaHccRatio();
523}
524
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("GammaHtobbRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->GammaHbbRatio();
534}
535
537: ThObservable(SM_i)
538{
539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
540 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
541}
542
544{
546}
547
548// -----------------------------------------------------------------------------
549// Branching Ratios
550// -----------------------------------------------------------------------------
551
553{
554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
555 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
556}
557
559{
560 return myNPbase->BrHtoinvRatio();
561}
562
564: ThObservable(SM_i)
565{
566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
567 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
568}
569
571{
572 return myNPbase->Br_H_inv();
573}
574
576: ThObservable(SM_i)
577{
578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
579 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
580}
581
583{
584 return myNPbase->Br_H_inv_NP();
585}
586
588: ThObservable(SM_i)
589{
590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
591 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
592}
593
595{
596 return myNPbase->Br_H_exo();
597}
598
600: ThObservable(SM_i)
601{
602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
603 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
604}
605
607{
608 return myNPbase->BrHvisRatio();
609}
610
612: ThObservable(SM_i)
613{
614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
615 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
616}
617
619{
620 return myNPbase->BrHggRatio();
621}
622
624: ThObservable(SM_i)
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHWWRatio();
633}
634
636: ThObservable(SM_i)
637{
638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
639 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
640}
641
643{
644 return myNPbase->BrHZZRatio();
645}
646
648: ThObservable(SM_i)
649{
650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
651 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
652}
653
655{
656 return myNPbase->BrHVVRatio();
657}
658
660{
661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
662 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
663}
664
666{
667 return myNPbase->BrHZgaRatio();
668}
669
671{
672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
673 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
674}
675
677{
678 return myNPbase->BrHZgallRatio();
679}
680
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
685}
686
688{
689 return myNPbase->BrHZgaeeRatio();
690}
691
693{
694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
695 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
696}
697
699{
700 return myNPbase->BrHZgamumuRatio();
701}
702
704{
705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
706 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
707}
708
710{
711 return myNPbase->BrHgagaRatio();
712}
713
715{
716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
717 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
718}
719
721{
722 return myNPbase->BrHmumuRatio();
723}
724
726{
727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
728 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
729}
730
732{
733 return myNPbase->BrHtautauRatio();
734}
735
737{
738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
739 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
740}
741
743{
744 return myNPbase->BrHccRatio();
745}
746
748{
749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
750 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
751}
752
754{
755 return myNPbase->BrHbbRatio();
756}
757
758// -----------------------------------------------------------------------------
759// More 4 fermion decays
760// -----------------------------------------------------------------------------
761
762
764: ThObservable(SM_i)
765{
766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
767 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
768}
769
771{
772 return myNPbase->BrH2l2vRatio();
773}
774
775
777: ThObservable(SM_i)
778{
779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
780 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
781}
782
784{
785 return myNPbase->BrHevmuvRatio();
786}
787
788
790: ThObservable(SM_i)
791{
792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
793 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
794}
795
797{
798 // SM decay widths (from MG simulations)
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
800
801 // Sum
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
803
804 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
805}
806
807
809: ThObservable(SM_i)
810{
811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
812 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
813}
814
816{
817 // SM decay widths (from MG simulations)
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
819
820 // Sum
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
822
823 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
824}
825
826
828: ThObservable(SM_i)
829{
830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
831 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
832}
833
835{
836 return myNPbase->BrH4lRatio();
837}
838
839
841: ThObservable(SM_i)
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
845}
846
848{
849 return myNPbase->BrH4eRatio();
850}
851
852
854: ThObservable(SM_i)
855{
856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
857 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
858}
859
861{
862 return myNPbase->BrH4muRatio();
863}
864
865
867: ThObservable(SM_i)
868{
869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
870 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
871}
872
874{
875 return myNPbase->BrH2e2muRatio();
876}
877
878
879
881: ThObservable(SM_i)
882{
883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
884 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
885}
886
888{
889 return myNPbase->BrHlljjRatio();
890}
891
892
894: ThObservable(SM_i)
895{
896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
897 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
898}
899
901{
902 return myNPbase->BrHlvjjRatio();
903}
904
905
907: ThObservable(SM_i)
908{
909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
910 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
911}
912
914{
915 return myNPbase->BrHlv_lvorjjRatio();
916}
917
918
920: ThObservable(SM_i)
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
924}
925
927{
928 return myNPbase->BrHll_vvorjjRatio();
929}
930
931// -----------------------------------------------------------------------------
932// Ratios of BR (ratios with SM)
933// -----------------------------------------------------------------------------
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
945 } else {
946 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
960 } else {
961 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
975 } else {
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
990 } else {
991 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
1005 } else {
1006 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
1007 }
1008}
1009
1010
1012{
1013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1014 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1015}
1016
1018{
1019 if ((this->getModel()).isModelLinearized()) {
1020 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
1021 } else {
1022 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
1023 }
1024}
1025
1026
1028{
1029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1030 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1031}
1032
1034{
1035 if ((this->getModel()).isModelLinearized()) {
1036 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
1037 } else {
1038 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
1039 }
1040}
1041
1042
1044{
1045 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1046 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1047}
1048
1050{
1051 if ((this->getModel()).isModelLinearized()) {
1052 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
1053 } else {
1054 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
1055 }
1056}
1057
1059{
1060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1061 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1062}
1063
1065{
1066 if ((this->getModel()).isModelLinearized()) {
1067 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
1068 } else {
1069 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
1070 }
1071}
1072
1074{
1075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1076 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1077}
1078
1080{
1081 if ((this->getModel()).isModelLinearized()) {
1082 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
1083 } else {
1084 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
1085 }
1086}
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
1098 } else {
1099 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
1100 }
1101}
1102
1104{
1105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1106 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1107}
1108
1110{
1111 if ((this->getModel()).isModelLinearized()) {
1112 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1113 } else {
1114 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1115 }
1116}
1117
1119{
1120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1121 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1122}
1123
1125{
1126 if ((this->getModel()).isModelLinearized()) {
1127 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1128 } else {
1129 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1130 }
1131}
1132
1134{
1135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1136 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1137}
1138
1140{
1141 if ((this->getModel()).isModelLinearized()) {
1142 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1143 } else {
1144 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1145 }
1146}
1147
1148
1150{
1151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1152 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1153}
1154
1156{
1157 if ((this->getModel()).isModelLinearized()) {
1158 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1159 } else {
1160 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1161 }
1162}
1163
1164
1166{
1167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1168 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1169}
1170
1172{
1173 if ((this->getModel()).isModelLinearized()) {
1174 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1175 } else {
1176 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1177 }
1178}
1179
1180
1182{
1183 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1184 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1185}
1186
1188{
1189 if ((this->getModel()).isModelLinearized()) {
1190 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1191 } else {
1192 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1193 }
1194}
1195
1196
1198{
1199 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1200 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1201}
1202
1204{
1205 if ((this->getModel()).isModelLinearized()) {
1206 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1207 } else {
1208 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1209 }
1210}
1211
1212
1214{
1215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1216 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1217}
1218
1220{
1221 if ((this->getModel()).isModelLinearized()) {
1222 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1223 } else {
1224 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1225 }
1226}
1227
1228
1229// -----------------------------------------------------------------------------
1230// Full signal strengths (prod x decay)
1231// -----------------------------------------------------------------------------
1232
1233muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1234: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1235{
1236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1237 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1238}
1239
1241{
1242 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1243 //AG: Most general expression including quadratic corrections.
1244 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1245 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1246 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1247 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1248 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1249 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1250
1251 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1252 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1253 double Br1 = dGammaR1-dGammaRTot1;
1254 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1255 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1256 } else {
1257 return myNPbase->muggHgaga(sqrt_s);
1258 }
1259}
1260
1261muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1262: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1263{
1264 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1265 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1266}
1267
1269{
1271}
1272
1273muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1274: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1275{
1276 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1277 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1278}
1279
1281{
1282 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1283 //AG: Most general expression including quadratic corrections.
1284 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1285 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1286 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1287 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1288 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1289 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1290
1291 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1292 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1293 double Br1 = dGammaR1-dGammaRTot1;
1294 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1295
1296 double mu;
1297
1298 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1299
1300 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1301
1302 return mu;
1303 } else {
1304 return myNPbase->muVBFHgaga(sqrt_s);
1305 }
1306}
1307
1308muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1309: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1310{
1311 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1312 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1313}
1314
1316{
1317 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1318 //AG: Most general expression including quadratic corrections.
1319 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1320 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1321 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1322 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1323 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1324 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1325
1326 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1327 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1328 double Br1 = dGammaR1-dGammaRTot1;
1329 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1330
1331 double mu;
1332
1333 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1334
1335 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1336
1337 return mu;
1338
1339 } else {
1340 return myNPbase->muZHgaga(sqrt_s);
1341 }
1342}
1343
1344muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1346{
1347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1348 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1349}
1350
1352{
1353 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1354 //AG: Most general expression including quadratic corrections.
1355 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1356 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1357 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1358 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1359 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1360 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1361
1362 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1363 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1364 double Br1 = dGammaR1-dGammaRTot1;
1365 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1366
1367 double mu;
1368
1369 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1370
1371 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1372
1373 return mu;
1374
1375 } else {
1376 return myNPbase->muWHgaga(sqrt_s);
1377 }
1378}
1379
1380muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1381: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1382{
1383 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1384 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1385}
1386
1388{
1389 if ((this->getModel()).isModelLinearized()) {
1390 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1391 } else {
1392 return myNPbase->muVHgaga(sqrt_s);
1393 }
1394}
1395
1396muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1397: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1398{
1399 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1400 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1401}
1402
1404{
1405 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1406 //AG: Most general expression including quadratic corrections.
1407 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1408 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1409 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1410 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1411 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1412 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1413
1414 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1415 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1416 double Br1 = dGammaR1-dGammaRTot1;
1417 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1418
1419 double mu;
1420
1421 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1422
1423 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1424
1425 return mu;
1426
1427 } else {
1428 return myNPbase->muttHgaga(sqrt_s);
1429 }
1430}
1431
1432mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1433: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1434{
1435 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1436 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1437}
1438
1440{
1441 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1442 //AG: Most general expression including quadratic corrections.
1443 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1444 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1445 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1446 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1447 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1448
1449 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1450 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1451 double Br1 = dGammaR1-dGammaRTot1;
1452 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1453
1454 double mu;
1455
1456 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1457
1458 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1459
1460 return mu;
1461
1462 } else {
1463 //VM: Just in case someone wants to add directly the production*decay
1464 //(which is the observable we fit at the end)
1465 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1466 if(NPmutHgaga==1.0){
1467 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1468 } else{
1469 return NPmutHgaga;
1470 }
1471 }
1472}
1473
1474muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1475: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1476{
1477 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1478 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1479}
1480
1482{
1483 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1484 //AG: Most general expression including quadratic corrections.
1485 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1486 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1487 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1488 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1489 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1490
1491 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1492 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1493 double Br1 = dGammaR1-dGammaRTot1;
1494 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1495
1496 double mu;
1497
1498 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1499
1500 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1501
1502 return mu;
1503
1504 } else {
1505 //VM: Just in case someone wants to add directly the production*decay
1506 //(which is the observable we fit at the end)
1507 //Also, the bbH is missing here, I'll leave it as it was for the
1508 //moment (since bbH is really suppressed).
1509 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1510 if (NPmuggHpbbH_Hgaga == 1.0){
1511 return (myNPbase->muggHgaga(sqrt_s));
1512 } else{
1513 return NPmuggHpbbH_Hgaga;
1514 }
1515 }
1516}
1517
1518muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1519: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1520{
1521 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1522 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1523}
1524
1526{
1527 //VM:Note that these values are valid for 13 TeV, they are not general
1528 //We should access the SM function that has all the values (for the
1529 //different energies). The values are slightly different, we should
1530 //check this.
1531 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1532 double xsSM_ttH = 0.499873;
1533 double xsSM_tH = 0.0821;
1534 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1535 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1536
1537 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1538 //AG: Most general expression including quadratic corrections.
1539 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1540 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1541 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1542 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1543 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1544
1545 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1546 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1547 double Br1 = dGammaR1-dGammaRTot1;
1548 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1549
1550 double mu;
1551
1552 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1553
1554 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1555
1556 return mu;
1557
1558 } else {
1559 //VM: Just in case someone wants to add directly the production*decay
1560 //(which is the observable we fit at the end)
1561 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1562 if(NPmuttHptH_Hgaga==1.0){
1563 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1564 } else {
1565 return NPmuttHptH_Hgaga;
1566 }
1567 }
1568}
1569
1570muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1571: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1572{
1573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1574 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1575}
1576
1578{
1579 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1580 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1581 //AG: Most general expression including quadratic corrections.
1582 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1583 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1584 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1585 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1586 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1587
1588 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1589 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1590 double Br1 = dGammaR1-dGammaRTot1;
1591 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1592
1593 double mu;
1594
1595 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1596
1597 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1598
1599 return mu;
1600
1601 } else {
1602 return myNPbase->muggHZga(sqrt_s);
1603 }
1604}
1605
1606muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1607: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1608{
1609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1610 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1611}
1612
1614{
1615 if ((this->getModel()).isModelLinearized()) {
1616 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1617 } else {
1619 }
1620}
1621
1622muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1623: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1624{
1625 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1626 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1627}
1628
1630{
1631 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1632 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1633 //AG: Most general expression including quadratic corrections.
1634 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1635 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1636 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1637 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1638 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1639
1640 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1641 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1642 double Br1 = dGammaR1-dGammaRTot1;
1643 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1644
1645 double mu;
1646
1647 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1648
1649 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1650
1651 return mu;
1652
1653 } else {
1654 return myNPbase->muVBFHZga(sqrt_s);
1655 }
1656}
1657
1658muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1659: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1660{
1661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1662 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1663}
1664
1666{
1667 if ((this->getModel()).isModelLinearized()) {
1668 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1669 } else {
1670 return myNPbase->muZHZga(sqrt_s);
1671 }
1672}
1673
1674muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1675: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1676{
1677 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1678 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1679}
1680
1682{
1683 if ((this->getModel()).isModelLinearized()) {
1684 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1685 } else {
1686 return myNPbase->muWHZga(sqrt_s);
1687 }
1688}
1689
1690muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1691: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1692{
1693 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1694 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1695}
1696
1698{
1699 if ((this->getModel()).isModelLinearized()) {
1700 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1701 } else {
1702 return myNPbase->muVHZga(sqrt_s);
1703 }
1704}
1705
1706muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1707: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1708{
1709 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1710 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1711}
1712
1714{
1715 if ((this->getModel()).isModelLinearized()) {
1716 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1717 } else {
1718 return myNPbase->muttHZga(sqrt_s);
1719 }
1720}
1721
1722muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1723: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1724{
1725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1726 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1727}
1728
1730{
1731 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1732 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1733 //AG: Most general expression including quadratic corrections.
1734 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1735 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1736 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1737 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1738 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1739
1740 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1741 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1742 double Br1 = dGammaR1-dGammaRTot1;
1743 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1744
1745 double mu;
1746
1747 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1748
1749 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1750
1751 return mu;
1752
1753 } else {
1754 return myNPbase->muggHZZ(sqrt_s);
1755 }
1756}
1757
1758muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1759: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1760{
1761 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1762 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1763}
1764
1766{
1767 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1768 //AG: Most general expression including quadratic corrections.
1769 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1770 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1771 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1772 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1773 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1774 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1775
1776 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1777 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1778 double Br1 = dGammaR1-dGammaRTot1;
1779 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1780
1781 double mu;
1782
1783 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1784
1785 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1786
1787 return mu;
1788
1789 } else {
1790 return myNPbase->muVBFHZZ(sqrt_s);
1791 }
1792}
1793
1794muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1795: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1796{
1797 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1798 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1799}
1800
1802{
1803 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1804 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1805 //AG: Most general expression including quadratic corrections.
1806 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1807 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1808 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1809 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1810 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1811
1812 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1813 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1814 double Br1 = dGammaR1-dGammaRTot1;
1815 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1816
1817 double mu;
1818
1819 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1820
1821 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1822
1823 return mu;
1824
1825 } else {
1826 return myNPbase->muZHZZ(sqrt_s);
1827 }
1828}
1829
1830muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1831: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1832{
1833 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1834 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1835}
1836
1838{
1839 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1840 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1841 //AG: Most general expression including quadratic corrections.
1842 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1843 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1844 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1845 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1846 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1847
1848 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1849 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1850 double Br1 = dGammaR1-dGammaRTot1;
1851 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1852
1853 double mu;
1854
1855 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1856
1857 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1858
1859 return mu;
1860
1861 } else {
1862 return myNPbase->muWHZZ(sqrt_s);
1863 }
1864}
1865
1866muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1867: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1868{
1869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1870 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1871}
1872
1874{
1875 //VM:Note that these values are valid for 13 TeV, they are not general
1876 //We should access the SM function that has all the values (for the
1877 //different energies). The values are slightly different, we should
1878 //check this.
1879 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1880 double xsSM_WH = 1.21539;
1881 double xsSM_ZH = 0.795910;
1882 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1883 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1884 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1885 //AG: Most general expression including quadratic corrections.
1886 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1887 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1888 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1889 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1890 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1891 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1892
1893 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1894 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1895 double Br1 = dGammaR1-dGammaRTot1;
1896 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1897
1898 double mu;
1899
1900 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1901
1902 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1903
1904 return mu;
1905
1906 } else {
1907 //return myNPbase->muVHZZ(sqrt_s);
1908 //VM: Just in case someone wants to add directly the production*decay
1909 //(which is the observable we fit at the end)
1910 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1911 if(NPmuVHZZ==1.0){
1912 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1913 } else {
1914 return NPmuVHZZ;
1915 }
1916 }
1917}
1918
1919muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1920: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1921{
1922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1923 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1924}
1925
1927{
1928 if ((this->getModel()).isModelLinearized()) {
1929 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1930 } else {
1931 return myNPbase->muttHZZ(sqrt_s);
1932 }
1933}
1934
1935muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1936: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1937{
1938 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1939 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1940}
1941
1943{
1944 //VM:Note that these values are valid for 13 TeV, they are not general
1945 //We should access the SM function that has all the values (for the
1946 //different energies). The values are slightly different, we should
1947 //check this.
1948 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1949 double xsSM_ttH = 0.499873;
1950 double xsSM_tH = 0.0821;
1951 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1952 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1953 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1954 //AG: Most general expression including quadratic corrections.
1955 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1956 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1957 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1958 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1959 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1960 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1961
1962 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1963 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1964 double Br1 = dGammaR1-dGammaRTot1;
1965 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1966
1967 double mu;
1968
1969 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1970
1971 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1972
1973 return mu;
1974
1975 } else {
1976
1977 //VM: Just in case someone wants to add directly the production*decay
1978 //(which is the observable we fit at the end)
1979 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
1980 if(NPmuttHptH_HZZ==1.0){
1981 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
1982 } else {
1983 return NPmuttHptH_HZZ;
1984 }
1985 }
1986}
1987
1988muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1989: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1990{
1991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1992 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
1993}
1994
1996{
1997 //VM:Note that these values are valid for 13 TeV, they are not general
1998 //We should access the SM function that has all the values (for the
1999 //different energies). The values are slightly different, we should
2000 //check this.
2001 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2002 double xsSM_ttH = 0.499873;
2003 double xsSM_tH = 0.0821;
2004 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2005 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2006 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2007 //return ( 1.0
2008 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
2009 // + (myNPbase->BrHmumuRatio()-1.));
2010 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
2011 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2012 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2013 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2014
2015 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2016 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2017 double Br1 = dGammaR1-dGammaRTot1;
2018 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2019
2020 double mu;
2021
2022 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2023
2024 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2025
2026 return mu;
2027
2028 } else {
2029
2030 //VM: Just in case someone wants to add directly the production*decay
2031 //(which is the observable we fit at the end)
2032 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
2033 if(NPmuttHptH_Hmumu==1.0){
2034 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
2035 } else {
2036 return NPmuttHptH_Hmumu;
2037 }
2038 }
2039}
2040
2041muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2042: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2043{
2044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2045 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
2046}
2047
2049{
2050 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2051 //AG: Most general expression including quadratic corrections.
2052 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2053 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
2054 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2055 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2056 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2057 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2058
2059 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2060 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2061 double Br1 = dGammaR1-dGammaRTot1;
2062 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2063
2064 double mu;
2065
2066 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2067
2068 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2069
2070 return mu;
2071
2072 } else {
2073 //VM: Just in case someone wants to add directly the production*decay
2074 //(which is the observable we fit at the end)
2075 //Also, the bbH is missing here, I'll leave it as it was for the
2076 //moment (since bbH is really suppressed in the SM).
2077 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
2078 if (NPmuggHpbbH_HZZ == 1.0){
2079 return (myNPbase->muggHZZ(sqrt_s));
2080 } else{
2081 return NPmuggHpbbH_HZZ;
2082 }
2083 }
2084}
2085
2086muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2088{
2089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2090 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
2091}
2092
2094{
2095 if ((this->getModel()).isModelLinearized()) {
2096 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2097 } else {
2098 return myNPbase->muggHZZ4l(sqrt_s);
2099 }
2100}
2101
2102muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
2103: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2104{
2105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2106 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
2107}
2108
2110{
2111 if ((this->getModel()).isModelLinearized()) {
2112 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2113 } else {
2114 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2115 }
2116}
2117
2118muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2119: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2120{
2121 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2122 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2123}
2124
2126{
2127 if ((this->getModel()).isModelLinearized()) {
2128 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2129 } else {
2130 return myNPbase->muVBFHZZ4l(sqrt_s);
2131 }
2132}
2133
2134muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2135: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2136{
2137 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2138 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2139}
2140
2142{
2143 if ((this->getModel()).isModelLinearized()) {
2144 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2145 } else {
2146 return myNPbase->muZHZZ4l(sqrt_s);
2147 }
2148}
2149
2150muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2151: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2152{
2153 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2154 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2155}
2156
2158{
2159 if ((this->getModel()).isModelLinearized()) {
2160 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2161 } else {
2162 return myNPbase->muWHZZ4l(sqrt_s);
2163 }
2164}
2165
2166muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2167: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2168{
2169 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2170 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2171}
2172
2174{
2175 if ((this->getModel()).isModelLinearized()) {
2176 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2177 } else {
2178 return myNPbase->muVHZZ4l(sqrt_s);
2179 }
2180}
2181
2182muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2183: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2184{
2185 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2186 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2187}
2188
2190{
2191 if ((this->getModel()).isModelLinearized()) {
2192 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2193 } else {
2194 return myNPbase->muttHZZ4l(sqrt_s);
2195 }
2196}
2197
2198muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2199: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2200{
2201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2202 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2203}
2204
2206{
2207 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2208 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2209 //AG: Most general expression including quadratic corrections.
2210 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2211 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2212 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2213 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2214 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2215
2216 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2217 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2218 double Br1 = dGammaR1-dGammaRTot1;
2219 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2220
2221 double mu;
2222
2223 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2224
2225 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2226
2227 return mu;
2228
2229 } else {
2230 return myNPbase->muggHWW(sqrt_s);
2231 }
2232}
2233
2234muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2235: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2236{
2237 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2238 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2239}
2240
2242{
2243 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2244 //AG: Most general expression including quadratic corrections.
2245 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2246 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2247 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2248 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2249 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2250 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2251
2252 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2253 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2254 double Br1 = dGammaR1-dGammaRTot1;
2255 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2256
2257 double mu;
2258
2259 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2260
2261 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2262
2263 return mu;
2264
2265 } else {
2266 return myNPbase->muVBFHWW(sqrt_s);
2267 }
2268}
2269
2270muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2271: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2272{
2273 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2274 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2275}
2276
2278{
2279 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2280 //AG: Most general expression including quadratic corrections.
2281 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2282 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2283 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2284 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2285 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2286 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2287
2288 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2289 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2290 double Br1 = dGammaR1-dGammaRTot1;
2291 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2292
2293 double mu;
2294
2295 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2296
2297 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2298
2299 return mu;
2300
2301 } else {
2302 return myNPbase->muZHWW(sqrt_s);
2303 }
2304}
2305
2306muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2307: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2308{
2309 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2310 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2311}
2312
2314{
2315 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2316 //AG: Most general expression including quadratic corrections.
2317 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2318 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2319 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2320 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2321 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2322 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2323
2324 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2325 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2326 double Br1 = dGammaR1-dGammaRTot1;
2327 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2328
2329 double mu;
2330
2331 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2332
2333 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2334
2335 return mu;
2336
2337 } else {
2338 return myNPbase->muWHWW(sqrt_s);
2339 }
2340}
2341
2342muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2343: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2344{
2345 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2346 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2347}
2348
2350{
2351 if ((this->getModel()).isModelLinearized()) {
2352 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2353 } else {
2354 return myNPbase->muVHWW(sqrt_s);
2355 }
2356}
2357
2358muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2360{
2361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2362 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2363}
2364
2366{
2367 if ((this->getModel()).isModelLinearized()) {
2368 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2369 } else {
2370 return myNPbase->muttHWW(sqrt_s);
2371 }
2372}
2373
2374muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2375: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2376{
2377 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2378 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2379}
2380
2382{
2383
2384 //VM:Note that these values are valid for 13 TeV, they are not general
2385 //We should access the SM function that has all the values (for the
2386 //different energies). The values are slightly different, we should
2387 //check this.
2388 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2389 double xsSM_ttH = 0.499873;
2390 double xsSM_tH = 0.0821;
2391 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2392 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2393 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2394 //AG: Most general expression including quadratic corrections.
2395 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2396 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2397 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2398 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2399 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2400
2401 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2402 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2403 double Br1 = dGammaR1-dGammaRTot1;
2404 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2405
2406 double mu;
2407
2408 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2409
2410 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2411
2412 return mu;
2413
2414 } else {
2415
2416 //VM: Just in case someone wants to add directly the production*decay
2417 //(which is the observable we fit at the end)
2418 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2419 if(NPmuttHptH_HWW==1.0){
2420 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2421 } else {
2422 return NPmuttHptH_HWW;
2423 }
2424 }
2425}
2426
2427muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2428: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2429{
2430 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2431 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2432}
2433
2435{
2436 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2437 //AG: Most general expression including quadratic corrections.
2438 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2439 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2440 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2441 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2442 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2443 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2444
2445 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2446 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2447 double Br1 = dGammaR1-dGammaRTot1;
2448 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2449
2450 double mu;
2451
2452 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2453
2454 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2455
2456 return mu;
2457
2458 } else {
2459
2460 //VM: Just in case someone wants to add directly the production*decay
2461 //(which is the observable we fit at the end)
2462 //Also, the bbH is missing here, I'll leave it as it was for the
2463 //moment (since bbH is really suppressed in the SM).
2464 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2465 if (NPmuggHpbbH_HWW == 1.0){
2466 return (myNPbase->muggHWW(sqrt_s));
2467 } else{
2468 return NPmuggHpbbH_HWW;
2469 }
2470 }
2471}
2472
2473muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2474: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2475{
2476 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2477 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2478}
2479
2481{
2482 if ((this->getModel()).isModelLinearized()) {
2483 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2484 } else {
2485 return myNPbase->muggHWW2l2v(sqrt_s);
2486 }
2487}
2488
2489muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2491{
2492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2493 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2494}
2495
2497{
2498 if ((this->getModel()).isModelLinearized()) {
2499 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2500 } else {
2501 return myNPbase->muVBFHWW2l2v(sqrt_s);
2502 }
2503}
2504
2505muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2506: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2507{
2508 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2509 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2510}
2511
2513{
2514 if ((this->getModel()).isModelLinearized()) {
2515 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2516 } else {
2517 return myNPbase->muZHWW2l2v(sqrt_s);
2518 }
2519}
2520
2521muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2522: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2523{
2524 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2525 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2526}
2527
2529{
2530 if ((this->getModel()).isModelLinearized()) {
2531 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2532 } else {
2533 return myNPbase->muWHWW2l2v(sqrt_s);
2534 }
2535}
2536
2537muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2538: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2539{
2540 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2541 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2542}
2543
2545{
2546 if ((this->getModel()).isModelLinearized()) {
2547 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2548 } else {
2549 return myNPbase->muVHWW2l2v(sqrt_s);
2550 }
2551}
2552
2553muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2554: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2555{
2556 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2557 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2558}
2559
2561{
2562 if ((this->getModel()).isModelLinearized()) {
2563 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2564 } else {
2565 return myNPbase->muttHWW2l2v(sqrt_s);
2566 }
2567}
2568
2569muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2570: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2571{
2572 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2573 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2574}
2575
2577{
2578 if ((this->getModel()).isModelLinearized()) {
2579 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2580 } else {
2581 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2582 }
2583}
2584
2585muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2586: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2587{
2588 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2589 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2590}
2591
2593{
2594 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2595 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2596 //AG: Most general expression including quadratic corrections.
2597 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2598 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2599 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2600 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2601 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2602
2603 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2604 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2605 double Br1 = dGammaR1-dGammaRTot1;
2606 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2607
2608 double mu;
2609
2610 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2611
2612 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2613
2614 return mu;
2615
2616 } else {
2617 return myNPbase->muggHmumu(sqrt_s);
2618 }
2619}
2620
2621muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2622: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2623{
2624 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2625 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2626}
2627
2629{
2630 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2631 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2632 //AG: Most general expression including quadratic corrections.
2633 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2634 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2635 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2636 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2637 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2638
2639 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2640 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2641 double Br1 = dGammaR1-dGammaRTot1;
2642 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2643
2644 double mu;
2645
2646 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2647
2648 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2649
2650 return mu;
2651
2652 } else {
2653 return myNPbase->muVBFHmumu(sqrt_s);
2654 }
2655}
2656
2657muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2658: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2659{
2660 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2661 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2662}
2663
2665{
2666 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2667 //AG: Most general expression including quadratic corrections.
2668 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2669 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2670 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2671 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2672 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2673
2674 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2675 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2676 double Br1 = dGammaR1-dGammaRTot1;
2677 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2678
2679 double mu;
2680
2681 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2682
2683 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2684
2685 return mu;
2686
2687 } else {
2688 return myNPbase->muZHmumu(sqrt_s);
2689 }
2690}
2691
2692muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2694{
2695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2696 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2697}
2698
2700{
2701 if ((this->getModel()).isModelLinearized()) {
2702 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2703 } else {
2704 return myNPbase->muWHmumu(sqrt_s);
2705 }
2706}
2707
2708muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2709: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2710{
2711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2712 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2713}
2714
2716{
2717
2718 //VM:Note that these values are valid for 13 TeV, they are not general
2719 //We should access the SM function that has all the values (for the
2720 //different energies). The values are slightly different, we should
2721 //check this.
2722 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2723 double xsSM_WH = 1.21539;
2724 double xsSM_ZH = 0.795910;
2725 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2726 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2727 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2728 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2729 //AG: Most general expression including quadratic corrections.
2730 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2731 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2732 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2733 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2734 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2735
2736 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2737 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2738 double Br1 = dGammaR1-dGammaRTot1;
2739 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2740
2741 double mu;
2742
2743 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2744
2745 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2746
2747 return mu;
2748
2749 } else {
2750 //return myNPbase->muVHmumu(sqrt_s);
2751 //VM: Just in case someone wants to add directly the production*decay
2752 //(which is the observable we fit at the end)
2753 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2754 if(NPmuVHmumu==1.0){
2755 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2756 } else {
2757 return NPmuVHmumu;
2758 }
2759
2760 }
2761}
2762
2763muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2765{
2766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2767 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2768}
2769
2771{
2772 if ((this->getModel()).isModelLinearized()) {
2773 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2774 } else {
2775 return myNPbase->muttHmumu(sqrt_s);
2776 }
2777}
2778
2779muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2780: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2781{
2782 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2783 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2784}
2785
2787{
2788 //VM:Note that these values are valid for 13 TeV, they are not general
2789 //We should access the SM function that has all the values (for the
2790 //different energies). The values are slightly different, we should
2791 //check this. Furthermore, the bbH is not included. In the SM this is
2792 //very suppressed (and it's probably also the case in the SMEFT) but
2793 //in some NP models it may not be the case.Unfortunately, bbH is not
2794 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2795 //SMEFT and add here the general expression.
2796 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2797 double xsSM_ggHbbH = 44.745;
2798 double xsSM_ttH = 0.4998;
2799 double xsSM_tH = 0.084769;
2800 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2801 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2802 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2803 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2804
2805
2806
2807 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2808 //AG: Most general expression including quadratic corrections.
2809 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2810 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2811 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2812 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2813 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2814
2815 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2816 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2817 double Br1 = dGammaR1-dGammaRTot1;
2818 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2819
2820 double mu;
2821
2822 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2823
2824 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2825
2826 return mu;
2827
2828 } else {
2829
2830 //VM: Just in case someone wants to add directly the production*decay
2831 //(which is the observable we fit at the end). Furthermore, the Hbb
2832 //is not added in the original formula, fine for the SM (probably also
2833 //for the SMEFT) but not for all NP models.
2834 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2835 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2836 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2837 } else {
2838 return NPmuggHpttHptHpbbH_Hmumu;
2839 }
2840 }
2841}
2842
2843muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2845{
2846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2847 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2848}
2849
2851{
2852
2853 //VM:Note that these values are valid for 13 TeV, they are not general
2854 //We should access the SM function that has all the values (for the
2855 //different energies). The values are slightly different, we should
2856 //check this.
2857 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2858 double xsSM_VBF = 3.49948;
2859 double xsSM_WH = 1.21539;
2860 double xsSM_ZH = 0.795910;
2861 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2862 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2863 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2864 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2865 //AG: Most general expression including quadratic corrections.
2866 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2867 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2868 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2869 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2870 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2871
2872 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2873 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2874 double Br1 = dGammaR1-dGammaRTot1;
2875 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2876
2877 double mu;
2878
2879 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2880
2881 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2882
2883 return mu;
2884
2885 } else {
2886
2887 //VM: Just in case someone wants to add directly the production*decay
2888 //(which is the observable we fit at the end).
2889 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2890 if(NPmuVBFpVH_Hmumu==1.0){
2891 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2892 } else {
2893 return NPmuVBFpVH_Hmumu;
2894 }
2895 }
2896}
2897
2898muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2899: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2900{
2901 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2902 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2903}
2904
2906{
2907 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2908 //AG: Most general expression including quadratic corrections.
2909 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2910 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2911 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2912 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2913 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2914 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2915
2916 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2917 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2918 double Br1 = dGammaR1-dGammaRTot1;
2919 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2920
2921 double mu;
2922
2923 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2924
2925 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2926
2927 return mu;
2928
2929 } else {
2930 return myNPbase->muggHtautau(sqrt_s);
2931 }
2932}
2933
2934muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2935: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2936{
2937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2938 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2939}
2940
2942{
2943 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2944 //AG: Most general expression including quadratic corrections.
2945 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2946 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2947 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2948 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2949 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2950 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2951
2952 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2953 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2954 double Br1 = dGammaR1-dGammaRTot1;
2955 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2956
2957 double mu;
2958
2959 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2960
2961 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2962
2963 return mu;
2964
2965 } else {
2966 return myNPbase->muVBFHtautau(sqrt_s);
2967 }
2968}
2969
2970
2971
2972muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2974{
2975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2976 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
2977}
2978
2980{
2981 if ((this->getModel()).isModelLinearized()) {
2982 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2983 } else {
2985 }
2986}
2987
2988
2989muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2991{
2992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2993 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
2994}
2995
2996double muZHtautau::computeThValue() //AG:modified
2997{
2998 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2999 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3000 //AG: Most general expression including quadratic corrections.
3001 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3002 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3003 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3004 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3005 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3006 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3007
3008 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3009 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3010 double Br1 = dGammaR1-dGammaRTot1;
3011 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3012
3013 double mu;
3014
3015 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3016
3017 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3018
3019 return mu;
3020
3021 } else {
3022 return myNPbase->muZHtautau(sqrt_s);
3023 }
3024}
3025
3026muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3027: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3028{
3029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3030 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
3031}
3032
3034{
3035 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3036 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3037 //AG: Most general expression including quadratic corrections.
3038 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3039 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3040 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3041 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3042 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3043
3044 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3045 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3046 double Br1 = dGammaR1-dGammaRTot1;
3047 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3048
3049 /*std::cout << "muProd1="<<muProd1<<std::endl;
3050 std::cout << "muProd2="<<muProd2<<std::endl;
3051 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
3052 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
3053 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
3054 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
3055
3056 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
3057 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
3058
3059 double mu;
3060
3061 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3062
3063 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3064
3065 return mu;
3066
3067 } else {
3068 return myNPbase->muWHtautau(sqrt_s);
3069 }
3070}
3071
3072muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3073: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3074{
3075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3076 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
3077}
3078
3080{
3081 //VM:Note that these values are valid for 13 TeV, they are not general
3082 //We should access the SM function that has all the values (for the
3083 //different energies). The values are slightly different, we should
3084 //check this.
3085 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3086 double xsSM_WH = 1.21539;
3087 double xsSM_ZH = 0.795910;
3088 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3089 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3090 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3091 //AG: Most general expression including quadratic corrections.
3092 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3093 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3094 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3095 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3096 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3097 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3098
3099 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3100 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3101 double Br1 = dGammaR1-dGammaRTot1;
3102 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3103
3104 double mu;
3105
3106 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3107
3108 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3109
3110 return mu;
3111
3112 } else {
3113 //return myNPbase->muVHtautau(sqrt_s);
3114
3115 //VM: Just in case someone wants to add directly the production*decay
3116 //(which is the observable we fit at the end)
3117 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3118 if(NPmuVHtautau==1.0){
3119 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3120 } else {
3121 return NPmuVHtautau;
3122 }
3123 }
3124}
3125
3126muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3127: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3128{
3129 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3130 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3131}
3132
3134{
3135 if ((this->getModel()).isModelLinearized()) {
3136 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3137 } else {
3138 return myNPbase->muttHtautau(sqrt_s);
3139 }
3140}
3141
3142muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3143: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3144{
3145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3146 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3147}
3148
3150{
3151 //VM:Note that these values are valid for 13 TeV, they are not general
3152 //We should access the SM function that has all the values (for the
3153 //different energies). The values are slightly different, we should
3154 //check this.
3155 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3156 double xsSM_ttH = 0.499873;
3157 double xsSM_tH = 0.0821;
3158 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3159 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3160 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3161 //AG: Most general expression including quadratic corrections.
3162 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3163 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3164 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3165 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3166 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3167
3168 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3169 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3170 double Br1 = dGammaR1-dGammaRTot1;
3171 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3172
3173 double mu;
3174
3175 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3176
3177 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3178
3179 return mu;
3180
3181 } else {
3182
3183 //VM: Just in case someone wants to add directly the production*decay
3184 //(which is the observable we fit at the end)
3185 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3186 if(NPmuttHptH_Htautau==1.0){
3187 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3188 } else {
3189 return NPmuttHptH_Htautau;
3190 }
3191
3192 }
3193}
3194
3195muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3196: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3197{
3198 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3199 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3200}
3201
3203{
3204 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3205 //AG: Most general expression including quadratic corrections.
3206 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3207 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3208 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3209 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3210 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3211 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3212
3213 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3214 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3215 double Br1 = dGammaR1-dGammaRTot1;
3216 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3217
3218 double mu;
3219
3220 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3221
3222 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3223
3224 return mu;
3225
3226 } else {
3227
3228 //VM: Just in case someone wants to add directly the production*decay
3229 //(which is the observable we fit at the end)
3230 //Also, the bbH is missing here, I'll leave it as it was for the
3231 //moment (since bbH is really suppressed in the SM).
3232 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3233 if (NPmuggHpbbH_Htautau == 1.0){
3234 return (myNPbase->muggHtautau(sqrt_s));
3235 } else{
3236 return NPmuggHpbbH_Htautau;
3237 }
3238 }
3239}
3240
3241muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3242: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3243{
3244 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3245 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3246}
3247
3249{
3250 if ((this->getModel()).isModelLinearized()) {
3251 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3252 //AG: Most general expression including quadratic corrections.
3253 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3254 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3255 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3256 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3257 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3258
3259 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3260 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3261 double Br1 = dGammaR1-dGammaRTot1;
3262 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3263
3264 double mu;
3265
3266 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3267
3268 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3269
3270 return mu;
3271
3272 } else {
3273 return myNPbase->muggHbb(sqrt_s);
3274 }
3275}
3276
3277muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3278: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3279{
3280 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3281 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3282}
3283
3285{
3286 if ((this->getModel()).isModelLinearized()) {
3287 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3288 } else {
3289 return myNPbase->muVBFHbb(sqrt_s);
3290 }
3291}
3292
3293muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3294: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3295{
3296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3297 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3298}
3299
3301{
3302 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3303 //AG: Most general expression including quadratic corrections.
3304 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3305 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3306 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3307 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3308 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3309 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3310
3311 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3312 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3313 double Br1 = dGammaR1-dGammaRTot1;
3314 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3315
3316 double mu;
3317
3318 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3319
3320 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3321
3322 return mu;
3323
3324 } else {
3325 return myNPbase->muZHbb(sqrt_s);
3326 }
3327}
3328
3329muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3330: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3331{
3332 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3333 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3334}
3335
3337{
3338 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3339 //AG: Most general expression including quadratic corrections.
3340 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3341 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3342 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3343 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3344 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3345 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3346
3347 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3348 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3349 double Br1 = dGammaR1-dGammaRTot1;
3350 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3351
3352 double mu;
3353
3354 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3355
3356 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3357
3358 return mu;
3359
3360 } else {
3361 return myNPbase->muWHbb(sqrt_s);
3362 }
3363}
3364
3365muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3366: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3367{
3368 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3369 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3370}
3371
3373{
3374 if ((this->getModel()).isModelLinearized()) {
3375 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3376 } else {
3377 return myNPbase->muVHbb(sqrt_s);
3378 }
3379}
3380
3381muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3382: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3383{
3384 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3385 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3386}
3387
3389{
3390 if ((this->getModel()).isModelLinearized()) {
3391 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3392 } else {
3393 return myNPbase->muttHbb(sqrt_s);
3394 }
3395}
3396
3397muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3398: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3399{
3400 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3401 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3402}
3403
3405{
3406 //VM:Note that these values are valid for 13 TeV, they are not general
3407 //We should access the SM function that has all the values (for the
3408 //different energies). The values are slightly different, we should
3409 //check this.
3410 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3411 double xsSM_ttH = 0.499873;
3412 double xsSM_tH = 0.0821;
3413 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3414 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3415 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3416 //AG: Most general expression including quadratic corrections.
3417 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3418 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3419 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3420 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3421 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3422
3423 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3424 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3425 double Br1 = dGammaR1-dGammaRTot1;
3426 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3427
3428 double mu;
3429
3430 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3431
3432 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3433
3434 return mu;
3435
3436 } else {
3437
3438
3439 //VM: Just in case someone wants to add directly the production*decay
3440 //(which is the observable we fit at the end)
3441 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3442 if(NPmuttHptH_Hbb==1.0){
3443 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3444 } else {
3445 return NPmuttHptH_Hbb;
3446 }
3447 }
3448}
3449
3450muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3451: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3452{
3453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3454 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3455}
3456
3458{
3459 //VM:Note that these values are valid for 13 TeV, they are not general
3460 //We should access the SM function that has all the values (for the
3461 //different energies). The values are slightly different, we should
3462 //check this. Furthermore, the bbH is not included. In the SM this is
3463 //very suppressed (and it's probably also the case in the SMEFT) but
3464 //in some NP models it may not be the case.Unfortunately, bbH is not
3465 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3466 //SMEFT and add here the general expression.
3467 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3468 double xsSM_ggHbbH = 44.745;
3469 double xsSM_VBF = 3.49948;
3470 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3471 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3472 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3473 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3474 //AG: Most general expression including quadratic corrections.
3475 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3476 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3477 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3478 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3479 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3480
3481 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3482 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3483 double Br1 = dGammaR1-dGammaRTot1;
3484 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3485
3486 double mu;
3487
3488 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3489
3490 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3491
3492 return mu;
3493
3494 } else {
3495
3496
3497 //VM: Just in case someone wants to add directly the production*decay
3498 //(which is the observable we fit at the end). Furthermore, the Hbb
3499 //is not added in the original formula, fine for the SM (probably also
3500 //for the SMEFT) but not for all NP models.
3501 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3502 if(NPmuggHpVBFpbbH_Hbb==1.0){
3503 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3504 } else {
3505 return NPmuggHpVBFpbbH_Hbb;
3506 }
3507 }
3508}
3509
3510
3511
3512muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3513: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3514{
3515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3516 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3517}
3518
3520{
3521 if ((this->getModel()).isModelLinearized()) {
3522 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3523 } else {
3524 return myNPbase->muVHcc(sqrt_s);
3525 }
3526}
3527
3528
3529muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3530: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3531{
3532 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3533 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3534}
3535
3537{
3538
3539 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3540
3541}
3542
3543muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3544: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3545{
3546 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3547 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3548}
3549
3551{
3552
3553 if ((this->getModel()).isModelLinearized()) {
3554 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3555 } else {
3556 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3557 }
3558
3559}
3560
3561
3562muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3563: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3564{
3565 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3566 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3567}
3568
3570{
3571
3572 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3573
3574}
3575
3576muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3577: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3578{
3579 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3580 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3581}
3582
3584{
3585
3586 if ((this->getModel()).isModelLinearized()) {
3587 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3588 } else {
3589 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3590 }
3591
3592}
3593
3594
3595muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3596: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3597{
3598 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3599 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3600}
3601
3603{
3604 return myNPbase->muppHmumu(sqrt_s);
3605}
3606
3607muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3608: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3609{
3610 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3611 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3612}
3613
3615{
3616 return myNPbase->muppHZga(sqrt_s);
3617}
3618
3619muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3620: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3621{
3622 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3623 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3624}
3625
3627{
3628 if ((this->getModel()).isModelLinearized()) {
3629 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3630 } else {
3632 }
3633}
3634
3635muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3636: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3637{
3638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3639 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3640}
3641
3643{
3644 return (myNPbase->muttHZbbboost(sqrt_s));
3645}
3646
3647//AG:begin
3648ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3650{
3651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3652 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3653}
3655{
3656 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3657 if ((this->getModel()).isModelLinearized()) {
3658 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3659 } else {
3660 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3661 }
3662}
3663
3664
3665ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3666: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3667{
3668 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3669 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3670}
3672{
3673 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3674 if ((this->getModel()).isModelLinearized()) {
3675 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3676 } else {
3677 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3678 }
3679}
3680
3681
3682ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3683: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3684{
3685 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3686 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3687}
3689{
3690 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3691 if ((this->getModel()).isModelLinearized()) {
3692 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3693 } else {
3694 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3695 }
3696}
3697
3698
3699ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3700: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3701{
3702 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3703 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3704}
3706{
3707 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3708 if ((this->getModel()).isModelLinearized()) {
3709 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3710 } else {
3711 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3712 }
3713}
3714
3715
3716VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3717: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3718{
3719 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3720 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3721}
3723{
3724 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3725 if ((this->getModel()).isModelLinearized()) {
3726 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3727 } else {
3728 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3729 }
3730}
3731
3732
3733VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3734: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3735{
3736 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3737 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3738}
3740{
3741 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3742 if ((this->getModel()).isModelLinearized()) {
3743 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3744 } else {
3745 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3746 }
3747}
3748
3749
3750VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3751: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3752{
3753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3754 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3755}
3757{
3758 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3759 if ((this->getModel()).isModelLinearized()) {
3760 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3761 } else {
3762 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3763 }
3764}
3765
3766
3767VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3768: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3769{
3770 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3771 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3772}
3774{
3775 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3776 if ((this->getModel()).isModelLinearized()) {
3777 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3778 } else {
3779 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3780 }
3781}
3782
3783
3784WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3785: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3786{
3787 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3788 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3789}
3791{
3792 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3793 if ((this->getModel()).isModelLinearized()) {
3794 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3795 } else {
3796 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3797 }
3798}
3799
3800
3801WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3802: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3803{
3804 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3805 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3806}
3808{
3809 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3810 if ((this->getModel()).isModelLinearized()) {
3811 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3812 } else {
3813 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3814 }
3815}
3816
3817
3818WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3819: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3820{
3821 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3822 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3823}
3825{
3826 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3827 if ((this->getModel()).isModelLinearized()) {
3828 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3829 } else {
3830 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3831 }
3832}
3833
3834
3835WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3836: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3837{
3838 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3839 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3840}
3842{
3843 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3844 if ((this->getModel()).isModelLinearized()) {
3845 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3846 } else {
3847 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3848 }
3849}
3850
3851
3852ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3853: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3854{
3855 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3856 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3857}
3859{
3860 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3861 if ((this->getModel()).isModelLinearized()) {
3862 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3863 } else {
3864 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3865 }
3866}
3867
3868
3869ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3870: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3871{
3872 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3873 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3874}
3876{
3877 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3878 if ((this->getModel()).isModelLinearized()) {
3879 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3880 } else {
3881 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3882 }
3883}
3884
3885
3886ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3887: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3888{
3889 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3890 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3891}
3893{
3894 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3895 if ((this->getModel()).isModelLinearized()) {
3896 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3897 } else {
3898 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3899 }
3900}
3901
3902
3903ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3904: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3905{
3906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3907 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3908}
3910{
3911 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3912 if ((this->getModel()).isModelLinearized()) {
3913 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3914 } else {
3915 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3916 }
3917}
3918
3919
3920ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3921: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3922{
3923 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3924 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3925}
3927{
3928 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3929 if ((this->getModel()).isModelLinearized()) {
3930 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3931 } else {
3932 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3933 }
3934}
3935
3936
3937ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3938: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3939{
3940 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3941 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3942}
3944{
3945 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3946 if ((this->getModel()).isModelLinearized()) {
3947 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3948 } else {
3949 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3950 }
3951}
3952
3953
3954ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3956{
3957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3958 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
3959}
3961{
3962 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3963 if ((this->getModel()).isModelLinearized()) {
3964 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3965 } else {
3966 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
3967 }
3968}
3969
3970
3971ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3972: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3973{
3974 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3975 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
3976}
3978{
3979 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3980 if ((this->getModel()).isModelLinearized()) {
3981 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3982 } else {
3983 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
3984 }
3985}
3986
3987//AG:end
3988
3989UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3990{
3991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3992 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
3993}
3994
3996{
3998}
3999
4000UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4001{
4002 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4003 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4004}
4005
4007{
4009}
4010
4011UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4012{
4013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4014 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4015}
4016
4018{
4020}
4021
4022UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4023{
4024 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4025 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4026}
4027
4029{
4031}
4032
4034{
4035 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4036 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
4037}
4038
4040{
4041 return myNPbase->cgplusct();
4042}
4043
4045{
4046 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4047 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
4048}
4049
4051{
4052 return myNPbase->cgaplusct();
4053}
4054
4056{
4057 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4058 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
4059}
4060
4062{
4063 return myNPbase->cgminuscga();
4064}
4065
4067{
4068 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4069 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
4070}
4071\
4072
4073
4075{
4076 return myNPbase->cVpluscb();
4077}
4078
4080{
4081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4082 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
4083}
4084
4086{
4087 return myNPbase->cVplusctau();
4088}
4089
4091{
4092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4093 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
4094}
4095
4097{
4098 return myNPbase->cbminuscc();
4099}
4100
4102{
4103 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4104 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
4105}
4106
4108{
4109 return myNPbase->cbminusctau();
4110}
4111
4113{
4114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4115 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4116}
4117
4119{
4120 return myNPbase->ccminusctau();
4121}
4122
4123
4124// Full signal strengths at e+ e- colliders
4125// ----------------------------------------
4126
4127mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4128: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4129{
4130 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4131 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4132}
4133
4135{
4136 if ((this->getModel()).isModelLinearized()) {
4137 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4138 } else {
4140 }
4141}
4142
4143mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4144: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4145{
4146 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4147 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4148}
4149
4151{
4152 if ((this->getModel()).isModelLinearized()) {
4153 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4154 } else {
4156 }
4157}
4158
4159mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4160: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4161{
4162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4163 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4164}
4165
4167{
4168 if ((this->getModel()).isModelLinearized()) {
4169 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4170 } else {
4172 }
4173}
4174
4175mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4176: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4177{
4178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4179 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4180}
4181
4183{
4184 if ((this->getModel()).isModelLinearized()) {
4185 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4186 } else {
4188 }
4189}
4190
4191mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4192: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4193{
4194 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4195 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4196}
4197
4199{
4200 if ((this->getModel()).isModelLinearized()) {
4201 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4202 } else {
4204 }
4205}
4206
4207mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4208: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4209{
4210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4211 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4212}
4213
4215{
4216 if ((this->getModel()).isModelLinearized()) {
4217 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4218 } else {
4220 }
4221}
4222
4223mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4224: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4225{
4226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4227 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4228}
4229
4231{
4232 if ((this->getModel()).isModelLinearized()) {
4233 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4234 } else {
4236 }
4237}
4238
4239mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4240: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4241{
4242 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4243 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4244}
4245
4247{
4248 if ((this->getModel()).isModelLinearized()) {
4249 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4250 } else {
4252 }
4253}
4254
4255mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4256: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4257{
4258 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4259 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4260}
4261
4263{
4264 if ((this->getModel()).isModelLinearized()) {
4265 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4266 } else {
4268 }
4269}
4270
4271mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4272: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4273{
4274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4275 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4276}
4277
4279{
4280 if ((this->getModel()).isModelLinearized()) {
4281 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4282 } else {
4284 }
4285}
4286
4287mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4288: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4289{
4290 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4291 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4292}
4293
4295{
4296
4298
4299}
4300
4301mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4302: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4303{
4304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4305 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4306}
4307
4309{
4310
4311 if ((this->getModel()).isModelLinearized()) {
4312 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4313 } else {
4315 }
4316
4317}
4318
4319mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4320: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4321{
4322 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4323 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4324
4325}
4326
4328{
4329 if ((this->getModel()).isModelLinearized()) {
4330 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4331 } else {
4332 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4333 }
4334}
4335
4336mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4337: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4338{
4339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4340 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4341
4342}
4343
4345{
4346 if ((this->getModel()).isModelLinearized()) {
4347 return ((myNPbase->mueeWBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4348 } else {
4350 }
4351}
4352
4353mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4354: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4355{
4356 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4357 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4358
4359}
4360
4362{
4363 if ((this->getModel()).isModelLinearized()) {
4364 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4365 } else {
4366 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4367 }
4368}
4369
4370mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4372{
4373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4374 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4375
4376}
4377
4379{
4380 if ((this->getModel()).isModelLinearized()) {
4381 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4382 } else {
4383 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4384 }
4385}
4386
4387mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4389{
4390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4391 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4392
4393}
4394
4396{
4397 if ((this->getModel()).isModelLinearized()) {
4398 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4399 } else {
4400 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4401 }
4402}
4403
4404mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4405: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4406{
4407 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4408 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4409
4410}
4411
4413{
4414 if ((this->getModel()).isModelLinearized()) {
4415 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4416 } else {
4418 }
4419}
4420
4421mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4422: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4423{
4424 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4425 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4426
4427}
4428
4430{
4431 if ((this->getModel()).isModelLinearized()) {
4432 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4433 } else {
4434 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4435 }
4436}
4437
4438mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4439: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4440{
4441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4442 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4443
4444}
4445
4447{
4448 if ((this->getModel()).isModelLinearized()) {
4449 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4450 } else {
4451 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4452 }
4453}
4454
4455mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4456: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4457{
4458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4459 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4460
4461}
4462
4464{
4465 if ((this->getModel()).isModelLinearized()) {
4466 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4467 } else {
4469 }
4470}
4471
4472mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4473: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4474{
4475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4476 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4477
4478}
4479
4481{
4482 if ((this->getModel()).isModelLinearized()) {
4483 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4484 } else {
4486 }
4487}
4488
4489mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4491{
4492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4493 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4494
4495}
4496
4498{
4499 if ((this->getModel()).isModelLinearized()) {
4500 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4501 } else {
4502 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4503 }
4504}
4505
4506mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4507: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4508{
4509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4510 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4511
4512}
4513
4515{
4516 if ((this->getModel()).isModelLinearized()) {
4517 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4518 } else {
4520 }
4521}
4522
4523mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4524: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4525{
4526 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4527 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4528
4529}
4530
4532{
4533 if ((this->getModel()).isModelLinearized()) {
4534 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4535 } else {
4536 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4537 }
4538}
4539
4540mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4541: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4542{
4543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4544 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4545
4546}
4547
4549{
4550 if ((this->getModel()).isModelLinearized()) {
4551 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4552 } else {
4554 }
4555}
4556
4557mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4558: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4559{
4560 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4561 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4562
4563}
4564
4566{
4567 if ((this->getModel()).isModelLinearized()) {
4568 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4569 } else {
4570 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4571 }
4572}
4573
4574mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4575: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4576{
4577 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4578 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4579
4580}
4581
4583{
4584 if ((this->getModel()).isModelLinearized()) {
4585 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4586 } else {
4588 }
4589}
4590
4591mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4592: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4593{
4594 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4595 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4596
4597}
4598
4600{
4601 if ((this->getModel()).isModelLinearized()) {
4602 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4603 } else {
4604 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4605 }
4606}
4607
4608mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4609: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4610{
4611 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4612 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4613
4614}
4615
4617{
4618 if ((this->getModel()).isModelLinearized()) {
4619 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4620 } else {
4622 }
4623}
4624
4625mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4626: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4627{
4628 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4629 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4630
4631}
4632
4634{
4635 if ((this->getModel()).isModelLinearized()) {
4636 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4637 } else {
4639 }
4640}
4641
4642mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4643: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4644{
4645 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4646 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4647
4648}
4649
4651{
4652 if ((this->getModel()).isModelLinearized()) {
4653 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4654 } else {
4656 }
4657}
4658
4659mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4660: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4661{
4662 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4663 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4664
4665}
4666
4668{
4669 if ((this->getModel()).isModelLinearized()) {
4670 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4671 } else {
4672 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4673 }
4674}
4675
4676mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4677: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4678{
4679 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4680 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4681
4682}
4683
4685{
4686 if ((this->getModel()).isModelLinearized()) {
4687 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4688 } else {
4690 }
4691}
4692
4693mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4694: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4695{
4696 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4697 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4698
4699}
4700
4702{
4703 if ((this->getModel()).isModelLinearized()) {
4704 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4705 } else {
4706 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4707 }
4708}
4709
4710mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4711: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4712{
4713 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4714 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4715
4716}
4717
4719{
4720 if ((this->getModel()).isModelLinearized()) {
4721 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4722 } else {
4724 }
4725}
4726
4727mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4728: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4729{
4730 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4731 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4732
4733}
4734
4736{
4737 if ((this->getModel()).isModelLinearized()) {
4738 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4739 } else {
4741 }
4742}
4743
4744mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4745: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4746{
4747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4748 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4749
4750}
4751
4753{
4754 if ((this->getModel()).isModelLinearized()) {
4755 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4756 } else {
4758 }
4759}
4760
4761mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4762: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4763{
4764 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4765 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4766
4767}
4768
4770{
4771 if ((this->getModel()).isModelLinearized()) {
4772 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4773 } else {
4775 }
4776}
4777
4778mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4779: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4780{
4781 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4782 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4783
4784}
4785
4787{
4788 if ((this->getModel()).isModelLinearized()) {
4789 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4790 } else {
4792 }
4793}
4794
4795mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4797{
4798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4799 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4800}
4801
4803{
4804 if ((this->getModel()).isModelLinearized()) {
4805 return ((myNPbase->mueeZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4806 } else {
4807 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4808 }
4809}
4810
4811mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4812: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4813{
4814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4815 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4816}
4817
4819{
4820 if ((this->getModel()).isModelLinearized()) {
4821 return ((myNPbase->mueeZBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4822 } else {
4824 }
4825}
4826
4827mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4828: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4829{
4830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4831 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4832}
4833
4835{
4836 if ((this->getModel()).isModelLinearized()) {
4837 return ((myNPbase->mueettH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4838 } else {
4839 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4840 }
4841}
4842
4843mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4844: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4845{
4846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4847 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4848}
4849
4851{
4852 if ((this->getModel()).isModelLinearized()) {
4853 return ((myNPbase->mueettHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4854 } else {
4856 }
4857}
4858
4859
4860// Production signal strengths at mu+ mu- colliders
4861// ------------------------------------------------
4862
4863mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4864: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4865{
4866 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4867 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4868}
4869
4871{
4872 return myNPbase->mummZH(sqrt_s);
4873}
4874
4875
4876mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4877: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4878{
4879 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4880 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4881}
4882
4884{
4885 return myNPbase->mummHvv(sqrt_s);
4886}
4887
4888
4889mummHmm::mummHmm(const StandardModel& SM_i, const double sqrt_s_i)
4890: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4891{
4892 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4893 throw std::runtime_error("mummHmm called with a class whose parent is not NPbase");
4894}
4895
4897{
4898 return myNPbase->mummHmm(sqrt_s);
4899}
4900
4901
4902mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4903: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4904{
4905 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4906 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4907}
4908
4910{
4911 return myNPbase->mummttH(sqrt_s);
4912}
4913
4914
4915// Full signal strengths at mu+ mu- colliders
4916// -------------------------------------------
4917
4918
4919mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4920: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4921{
4922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4923 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
4924}
4925
4927{
4928 if ((this->getModel()).isModelLinearized()) {
4929 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4930 } else {
4931 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
4932 }
4933}
4934
4935mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
4936: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4937{
4938 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4939 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4940}
4941
4943{
4944 if ((this->getModel()).isModelLinearized()) {
4945 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4946 } else {
4947 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
4948 }
4949}
4950
4951mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
4952: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4953{
4954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4955 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
4956}
4957
4959{
4960 if ((this->getModel()).isModelLinearized()) {
4961 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4962 } else {
4963 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
4964 }
4965}
4966
4967mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
4968: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4969{
4970 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4971 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4972}
4973
4975{
4976 if ((this->getModel()).isModelLinearized()) {
4977 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4978 } else {
4979 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
4980 }
4981}
4982
4983mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4984: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4985{
4986 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4987 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
4988}
4989
4991{
4992 if ((this->getModel()).isModelLinearized()) {
4993 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4994 } else {
4996 }
4997}
4998
4999mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5000: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5001{
5002 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5003 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5004}
5005
5007{
5008 if ((this->getModel()).isModelLinearized()) {
5009 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5010 } else {
5011 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5012 }
5013}
5014
5015mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5016: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5017{
5018 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5019 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5020}
5021
5023{
5024 if ((this->getModel()).isModelLinearized()) {
5025 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5026 } else {
5027 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5028 }
5029}
5030
5031mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5032: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5033{
5034 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5035 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5036}
5037
5039{
5040 if ((this->getModel()).isModelLinearized()) {
5041 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5042 } else {
5043 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5044 }
5045}
5046
5047mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5048: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5049{
5050 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5051 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5052}
5053
5055{
5056 if ((this->getModel()).isModelLinearized()) {
5057 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5058 } else {
5059 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5060 }
5061}
5062
5063
5064
5065mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5066: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5067{
5068 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5069 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5070}
5071
5073{
5074 if ((this->getModel()).isModelLinearized()) {
5075 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5076 } else {
5077 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5078 }
5079}
5080
5081mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5082: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5083{
5084 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5085 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5086}
5087
5089{
5090 if ((this->getModel()).isModelLinearized()) {
5091 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5092 } else {
5093 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5094 }
5095}
5096
5097mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5098: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5099{
5100 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5101 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5102}
5103
5105{
5106 if ((this->getModel()).isModelLinearized()) {
5107 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5108 } else {
5109 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5110 }
5111}
5112
5113mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5114: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5115{
5116 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5117 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5118}
5119
5121{
5122 if ((this->getModel()).isModelLinearized()) {
5123 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5124 } else {
5125 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5126 }
5127}
5128
5129mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5130: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5131{
5132 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5133 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5134}
5135
5137{
5138 if ((this->getModel()).isModelLinearized()) {
5139 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5140 } else {
5142 }
5143}
5144
5145mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5146: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5147{
5148 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5149 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5150}
5151
5153{
5154 if ((this->getModel()).isModelLinearized()) {
5155 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5156 } else {
5157 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5158 }
5159}
5160
5161mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5162: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5163{
5164 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5165 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5166}
5167
5169{
5170 if ((this->getModel()).isModelLinearized()) {
5171 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5172 } else {
5173 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5174 }
5175}
5176
5177mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5178: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5179{
5180 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5181 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5182}
5183
5185{
5186 if ((this->getModel()).isModelLinearized()) {
5187 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5188 } else {
5189 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5190 }
5191}
5192
5193mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5194: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5195{
5196 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5197 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5198}
5199
5201{
5202 if ((this->getModel()).isModelLinearized()) {
5203 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5204 } else {
5205 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5206 }
5207}
5208
5209
5210
5211mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5212: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5213{
5214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5215 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5216}
5217
5219{
5220 if ((this->getModel()).isModelLinearized()) {
5221 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5222 } else {
5223 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5224 }
5225}
5226
5227mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5228: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5229{
5230 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5231 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5232}
5233
5235{
5236 if ((this->getModel()).isModelLinearized()) {
5237 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5238 } else {
5239 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5240 }
5241}
5242
5243mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5244: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5245{
5246 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5247 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5248}
5249
5251{
5252 if ((this->getModel()).isModelLinearized()) {
5253 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5254 } else {
5255 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5256 }
5257}
5258
5259mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5260: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5261{
5262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5263 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5264}
5265
5267{
5268 if ((this->getModel()).isModelLinearized()) {
5269 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5270 } else {
5271 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5272 }
5273}
5274
5275mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5276: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5277{
5278 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5279 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5280}
5281
5283{
5284 if ((this->getModel()).isModelLinearized()) {
5285 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5286 } else {
5288 }
5289}
5290
5291mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5293{
5294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5295 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5296}
5297
5299{
5300 if ((this->getModel()).isModelLinearized()) {
5301 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5302 } else {
5303 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5304 }
5305}
5306
5307mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5308: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5309{
5310 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5311 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5312}
5313
5315{
5316 if ((this->getModel()).isModelLinearized()) {
5317 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5318 } else {
5319 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5320 }
5321}
5322
5323mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5324: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5325{
5326 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5327 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5328}
5329
5331{
5332 if ((this->getModel()).isModelLinearized()) {
5333 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5334 } else {
5336 }
5337}
5338
5339mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5340: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5341{
5342 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5343 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5344}
5345
5347{
5348 if ((this->getModel()).isModelLinearized()) {
5349 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5350 } else {
5352 }
5353}
5354
5355
5356
5357mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5358: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5359{
5360 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5361 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5362}
5363
5365{
5366 if ((this->getModel()).isModelLinearized()) {
5367 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5368 } else {
5369 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5370 }
5371}
5372
5373mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5374: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5375{
5376 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5377 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5378}
5379
5381{
5382 if ((this->getModel()).isModelLinearized()) {
5383 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5384 } else {
5385 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5386 }
5387}
5388
5389mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5390: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5391{
5392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5393 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5394}
5395
5397{
5398 if ((this->getModel()).isModelLinearized()) {
5399 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5400 } else {
5401 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5402 }
5403}
5404
5405mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5406: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5407{
5408 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5409 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5410}
5411
5413{
5414 if ((this->getModel()).isModelLinearized()) {
5415 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5416 } else {
5417 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5418 }
5419}
5420
5421mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5422: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5423{
5424 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5425 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5426}
5427
5429{
5430 if ((this->getModel()).isModelLinearized()) {
5431 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5432 } else {
5434 }
5435}
5436
5437mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5438: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5439{
5440 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5441 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5442}
5443
5445{
5446 if ((this->getModel()).isModelLinearized()) {
5447 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5448 } else {
5449 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5450 }
5451}
5452
5453mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5454: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5455{
5456 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5457 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5458}
5459
5461{
5462 if ((this->getModel()).isModelLinearized()) {
5463 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5464 } else {
5465 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5466 }
5467}
5468
5469mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5470: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5471{
5472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5473 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5474}
5475
5477{
5478 if ((this->getModel()).isModelLinearized()) {
5479 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5480 } else {
5482 }
5483}
5484
5485mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5486: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5487{
5488 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5489 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5490}
5491
5493{
5494 if ((this->getModel()).isModelLinearized()) {
5495 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5496 } else {
5498 }
5499}
5500
5501
5502mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5503: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5504{
5505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5506 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5507}
5508
5510{
5511 if ((this->getModel()).isModelLinearized()) {
5512 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5513 } else {
5514 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5515 }
5516}
5517
5518mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5519: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5520{
5521 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5522 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5523}
5524
5526{
5527 if ((this->getModel()).isModelLinearized()) {
5528 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5529 } else {
5530 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5531 }
5532}
5533
5534mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5535: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5536{
5537 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5538 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5539}
5540
5542{
5543 if ((this->getModel()).isModelLinearized()) {
5544 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5545 } else {
5546 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5547 }
5548}
5549
5550mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5551: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5552{
5553 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5554 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5555}
5556
5558{
5559 if ((this->getModel()).isModelLinearized()) {
5560 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5561 } else {
5562 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5563 }
5564}
5565
5566mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5567: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5568{
5569 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5570 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5571}
5572
5574{
5575 if ((this->getModel()).isModelLinearized()) {
5576 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5577 } else {
5579 }
5580}
5581
5582mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5583: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5584{
5585 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5586 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5587}
5588
5590{
5591 if ((this->getModel()).isModelLinearized()) {
5592 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5593 } else {
5594 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5595 }
5596}
5597
5598mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5599: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5600{
5601 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5602 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5603}
5604
5606{
5607 if ((this->getModel()).isModelLinearized()) {
5608 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5609 } else {
5610 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5611 }
5612}
5613
5614mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5615: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5616{
5617 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5618 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5619}
5620
5622{
5623 if ((this->getModel()).isModelLinearized()) {
5624 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5625 } else {
5627 }
5628}
5629
5630mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5631: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5632{
5633 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5634 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5635}
5636
5638{
5639 if ((this->getModel()).isModelLinearized()) {
5640 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5641 } else {
5643 }
5644}
5645
5646
5647// The same in the narrow width approximation
5648
5649mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5650: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5651{
5652 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5653 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5654}
5655
5657{
5658 if ((this->getModel()).isModelLinearized()) {
5659 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5660 } else {
5661 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5662 }
5663}
5664
5665mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5666: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5667{
5668 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5669 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5670}
5671
5673{
5674 if ((this->getModel()).isModelLinearized()) {
5675 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5676 } else {
5677 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5678 }
5679}
5680
5681mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5682: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5683{
5684 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5685 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5686}
5687
5689{
5690 if ((this->getModel()).isModelLinearized()) {
5691 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5692 } else {
5693 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5694 }
5695}
5696
5697mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5698: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5699{
5700 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5701 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5702}
5703
5705{
5706 if ((this->getModel()).isModelLinearized()) {
5707 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5708 } else {
5709 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5710 }
5711}
5712
5713mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5714: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5715{
5716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5717 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5718}
5719
5721{
5722 if ((this->getModel()).isModelLinearized()) {
5723 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5724 } else {
5726 }
5727}
5728
5729mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5730: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5731{
5732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5733 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5734}
5735
5737{
5738 if ((this->getModel()).isModelLinearized()) {
5739 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5740 } else {
5741 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5742 }
5743}
5744
5745mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5746: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5747{
5748 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5749 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5750}
5751
5753{
5754 if ((this->getModel()).isModelLinearized()) {
5755 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5756 } else {
5758 }
5759}
5760
5761mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5762: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5763{
5764 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5765 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5766}
5767
5769{
5770 if ((this->getModel()).isModelLinearized()) {
5771 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5772 } else {
5774 }
5775}
5776
5777mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5778: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5779{
5780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5781 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5782}
5783
5785{
5786 if ((this->getModel()).isModelLinearized()) {
5787 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5788 } else {
5790 }
5791}
5792
5793// Full signal strengths at ep colliders
5794// -------------------------------------
5795
5796muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5797: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5798{
5799 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5800 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5801
5802}
5803
5805{
5806 if ((this->getModel()).isModelLinearized()) {
5807 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5808 } else {
5809 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5810 }
5811}
5812
5813muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5814: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5815{
5816 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5817 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5818
5819}
5820
5822{
5823 if ((this->getModel()).isModelLinearized()) {
5824 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5825 } else {
5826 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5827 }
5828}
5829
5830muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5831: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5832{
5833 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5834 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5835
5836}
5837
5839{
5840 if ((this->getModel()).isModelLinearized()) {
5841 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5842 } else {
5843 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5844 }
5845}
5846
5847muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5848: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5849{
5850 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5851 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5852
5853}
5854
5856{
5857 if ((this->getModel()).isModelLinearized()) {
5858 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5859 } else {
5861 }
5862}
5863
5864muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5865: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5866{
5867 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5868 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5869
5870}
5871
5873{
5874 if ((this->getModel()).isModelLinearized()) {
5875 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5876 } else {
5877 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5878 }
5879}
5880
5881muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5882: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5883{
5884 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5885 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5886
5887}
5888
5890{
5891 if ((this->getModel()).isModelLinearized()) {
5892 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5893 } else {
5895 }
5896}
5897
5898muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5899: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5900{
5901 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5902 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5903
5904}
5905
5907{
5908 if ((this->getModel()).isModelLinearized()) {
5909 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5910 } else {
5912 }
5913}
5914
5915muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5916: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5917{
5918 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5919 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5920
5921}
5922
5924{
5925 if ((this->getModel()).isModelLinearized()) {
5926 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5927 } else {
5928 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5929 }
5930}
5931
5932muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5933: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5934{
5935 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5936 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
5937
5938}
5939
5941{
5942 if ((this->getModel()).isModelLinearized()) {
5943 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5944 } else {
5945 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
5946 }
5947}
5948
5949muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5950: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5951{
5952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5953 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
5954
5955}
5956
5958{
5959 if ((this->getModel()).isModelLinearized()) {
5960 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5961 } else {
5962 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
5963 }
5964}
5965
5966muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5967: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5968{
5969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5970 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
5971
5972}
5973
5975{
5976 if ((this->getModel()).isModelLinearized()) {
5977 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5978 } else {
5980 }
5981}
5982
5983muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5984: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5985{
5986 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5987 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
5988
5989}
5990
5992{
5993 if ((this->getModel()).isModelLinearized()) {
5994 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5995 } else {
5996 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
5997 }
5998}
5999
6000muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6001: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6002{
6003 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6004 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6005
6006}
6007
6009{
6010 if ((this->getModel()).isModelLinearized()) {
6011 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6012 } else {
6014 }
6015}
6016
6017muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6018: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6019{
6020 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6021 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6022
6023}
6024
6026{
6027 if ((this->getModel()).isModelLinearized()) {
6028 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6029 } else {
6031 }
6032}
6033
6034
6035// -----------------------------------------------------------------------------
6036// STXS bins
6037// -----------------------------------------------------------------------------
6038
6039// -----------------------------------------------------------------------------
6040// Stage 0
6041// -----------------------------------------------------------------------------
6042
6043STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6044: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6045{
6046 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6047 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6048
6049}
6050
6052{
6053 return myNPbase->STXS0_qqH(sqrt_s);
6054}
6055
6056
6057// -----------------------------------------------------------------------------
6058// Stage 1
6059// -----------------------------------------------------------------------------
6060
6062: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6063{
6064 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6065 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6066
6067}
6068
6070{
6071 if ((this->getModel()).isModelLinearized()) {
6072 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6073 } else {
6075 }
6076}
6077
6078
6080: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6081{
6082 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6083 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6084
6085}
6086
6088{
6089 if ((this->getModel()).isModelLinearized()) {
6090 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6091 } else {
6093 }
6094}
6095
6096
6097STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6098: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6099{
6100 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6101 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6102
6103}
6104
6106{
6107 if ((this->getModel()).isModelLinearized()) {
6108 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6109 } else {
6111 }
6112}
6113
6115: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6116{
6117 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6118 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6119
6120}
6121
6123{
6124 if ((this->getModel()).isModelLinearized()) {
6125 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6126 } else {
6128 }
6129}
6130
6132: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6133{
6134 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6135 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6136
6137}
6138
6140{
6141 if ((this->getModel()).isModelLinearized()) {
6142 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6143 } else {
6145 }
6146}
6147
6149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6150{
6151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6152 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6153
6154}
6155
6157{
6158 if ((this->getModel()).isModelLinearized()) {
6159 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6160 } else {
6162 }
6163}
6164
6166: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6167{
6168 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6169 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6170
6171}
6172
6174{
6175 if ((this->getModel()).isModelLinearized()) {
6176 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6177 } else {
6179 }
6180}
6181
6183: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6184{
6185 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6186 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6187
6188}
6189
6191{
6192 if ((this->getModel()).isModelLinearized()) {
6193 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6194 } else {
6196 }
6197}
6198
6199
6201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6202{
6203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6204 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6205
6206}
6207
6209{
6210 if ((this->getModel()).isModelLinearized()) {
6211 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6212 } else {
6214 }
6215}
6216
6217
6219: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6220{
6221 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6222 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6223
6224}
6225
6227{
6228 if ((this->getModel()).isModelLinearized()) {
6229 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6230 } else {
6232 }
6233}
6234
6235
6237: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6238{
6239 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6240 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6241
6242}
6243
6245{
6246 if ((this->getModel()).isModelLinearized()) {
6247 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6248 } else {
6250 }
6251}
6252
6253
6255: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6256{
6257 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6258 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6259
6260}
6261
6263{
6264 if ((this->getModel()).isModelLinearized()) {
6265 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6266 } else {
6268 }
6269}
6270
6271
6273: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6274{
6275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6276 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6277
6278}
6279
6281{
6282 if ((this->getModel()).isModelLinearized()) {
6283 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6284 } else {
6286 }
6287}
6288
6289
6291: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6292{
6293 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6294 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6295
6296}
6297
6299{
6300 if ((this->getModel()).isModelLinearized()) {
6301 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6302 } else {
6304 }
6305}
6306
6307
6308
6310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6311{
6312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6313 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6314
6315}
6316
6318{
6319 if ((this->getModel()).isModelLinearized()) {
6320 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6321 } else {
6323 }
6324}
6325
6326
6327
6329: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6330{
6331 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6332 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6333
6334}
6335
6337{
6338 if ((this->getModel()).isModelLinearized()) {
6339 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6340 } else {
6342 }
6343}
6344
6345
6346
6348: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6349{
6350 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6351 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6352
6353}
6354
6356{
6357 if ((this->getModel()).isModelLinearized()) {
6358 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6359 } else {
6361 }
6362}
6363
6364
6365STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6366: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6367{
6368 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6369 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6370
6371}
6372
6374{
6375 if ((this->getModel()).isModelLinearized()) {
6376 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6377 } else {
6379 }
6380}
6381
6382
6384: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6385{
6386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6387 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6388
6389}
6390
6392{
6393 if ((this->getModel()).isModelLinearized()) {
6394 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6395 } else {
6397 }
6398}
6399
6401: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6402{
6403 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6404 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6405
6406}
6407
6409{
6410 if ((this->getModel()).isModelLinearized()) {
6411 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6412 } else {
6414 }
6415}
6416
6417
6419: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6420{
6421 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6422 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6423
6424}
6425
6427{
6428 if ((this->getModel()).isModelLinearized()) {
6429 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6430 } else {
6432 }
6433}
6434
6435
6436
6438: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6439{
6440 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6441 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6442
6443}
6444
6446{
6447 if ((this->getModel()).isModelLinearized()) {
6449 } else {
6451 }
6452}
6453
6454
6455
6457: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6458{
6459 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6460 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6461
6462}
6463
6465{
6466 if ((this->getModel()).isModelLinearized()) {
6468 } else {
6470 }
6471}
6472
6473
6475: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6476{
6477 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6478 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6479
6480}
6481
6483{
6484 if ((this->getModel()).isModelLinearized()) {
6485 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6486 } else {
6488 }
6489}
6490
6492: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6493{
6494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6495 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6496
6497}
6498
6500{
6501 if ((this->getModel()).isModelLinearized()) {
6502 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6503 } else {
6505 }
6506}
6507
6509: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6510{
6511 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6512 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6513
6514}
6515
6517{
6518 if ((this->getModel()).isModelLinearized()) {
6519 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6520 } else {
6522 }
6523}
6524
6525
6527: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6528{
6529 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6530 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6531
6532}
6533
6535{
6536 if ((this->getModel()).isModelLinearized()) {
6538 } else {
6540 }
6541}
6542
6543
6545: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6546{
6547 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6548 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6549
6550}
6551
6553{
6554 if ((this->getModel()).isModelLinearized()) {
6556 } else {
6558 }
6559}
6560
6561
6563: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6564{
6565 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6566 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6567
6568}
6569
6571{
6572 if ((this->getModel()).isModelLinearized()) {
6573 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6574 } else {
6576 }
6577}
6578
6579STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6580: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6581{
6582 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6583 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6584
6585}
6586
6588{
6589 if ((this->getModel()).isModelLinearized()) {
6590 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6591 } else {
6593 }
6594}
6595
6596
6598: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6599{
6600 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6601 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6602
6603}
6604
6606{
6607 if ((this->getModel()).isModelLinearized()) {
6608 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6609 } else {
6611 }
6612}
6613
6614
6616: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6617{
6618 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6619 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6620
6621}
6622
6624{
6625 if ((this->getModel()).isModelLinearized()) {
6626 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6627 } else {
6629 }
6630}
6631
6632
6633
6635: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6636{
6637 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6638 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6639
6640}
6641
6643{
6644 if ((this->getModel()).isModelLinearized()) {
6646 } else {
6648 }
6649}
6650
6651
6652
6654: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6655{
6656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6657 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6658
6659}
6660
6662{
6663 if ((this->getModel()).isModelLinearized()) {
6665 } else {
6667 }
6668}
6669
6670
6672: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6673{
6674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6675 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6676
6677}
6678
6680{
6681 if ((this->getModel()).isModelLinearized()) {
6682 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6683 } else {
6685 }
6686}
6687
6689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6690{
6691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6692 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6693
6694}
6695
6697{
6698 if ((this->getModel()).isModelLinearized()) {
6699 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6700 } else {
6702 }
6703}
6704
6706: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6707{
6708 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6709 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6710
6711}
6712
6714{
6715 if ((this->getModel()).isModelLinearized()) {
6716 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6717 } else {
6719 }
6720}
6721
6722
6724: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6725{
6726 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6727 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6728
6729}
6730
6732{
6733 if ((this->getModel()).isModelLinearized()) {
6735 } else {
6737 }
6738}
6739
6740
6742: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6743{
6744 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6745 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6746
6747}
6748
6750{
6751 if ((this->getModel()).isModelLinearized()) {
6753 } else {
6755 }
6756}
6757
6758
6760: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6761{
6762 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6763 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6764
6765}
6766
6768{
6769 if ((this->getModel()).isModelLinearized()) {
6770 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6771 } else {
6773 }
6774}
6775
6776
6778: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6779{
6780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6781 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6782
6783}
6784
6786{
6787 if ((this->getModel()).isModelLinearized()) {
6789 } else {
6791 }
6792}
6793
6794
6796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6797{
6798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6799 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6800
6801}
6802
6804{
6805 if ((this->getModel()).isModelLinearized()) {
6806 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6807 } else {
6809 }
6810}
6811
6812
6814: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6815{
6816 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6817 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6818
6819}
6820
6822{
6823 if ((this->getModel()).isModelLinearized()) {
6824 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6825 } else {
6827 }
6828}
6829
6830
6832: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6833{
6834 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6835 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6836
6837}
6838
6840{
6841 if ((this->getModel()).isModelLinearized()) {
6842 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6843 } else {
6845 }
6846}
6847
6848
6850: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6851{
6852 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6853 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6854
6855}
6856
6858{
6859 if ((this->getModel()).isModelLinearized()) {
6860 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6861 } else {
6863 }
6864}
6865
6866
6868: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6869{
6870 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6871 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6872
6873}
6874
6876{
6877 if ((this->getModel()).isModelLinearized()) {
6879 } else {
6881 }
6882}
6883
6884
6886: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6887{
6888 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6889 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6890
6891}
6892
6894{
6895 if ((this->getModel()).isModelLinearized()) {
6896 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6897 } else {
6899 }
6900}
6901
6902
6904: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6905{
6906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6907 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6908
6909}
6910
6912{
6913 if ((this->getModel()).isModelLinearized()) {
6914 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6915 } else {
6917 }
6918}
6919
6920
6922: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6923{
6924 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6925 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6926
6927}
6928
6930{
6931 if ((this->getModel()).isModelLinearized()) {
6932 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6933 } else {
6935 }
6936}
6937
6938
6940: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6941{
6942 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6943 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6944
6945}
6946
6948{
6949 if ((this->getModel()).isModelLinearized()) {
6950 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6951 } else {
6953 }
6954}
6955
6956
6957
6958// -----------------------------------------------------------------------------
6959// Stage 1.2
6960// -----------------------------------------------------------------------------
6961
6962STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6963: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6964{
6965 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6966 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
6967
6968}
6969
6971{
6972 double BrHXXRatio = 1.0;
6973 if (fstate == 1){
6974 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6975 } else if (fstate == 2){
6976 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6977 } else if (fstate == 3){
6978 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6979 } else if (fstate == 4){
6980 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6981 } else {
6982 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
6983 }
6984
6985 if ((this->getModel()).isModelLinearized()) {
6986 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
6987 } else {
6988 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
6989 }
6990}
6991
6992// -----------------------------------------------------------------------------
6993
6994STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6995: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6996{
6997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6998 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
6999
7000}
7001
7003{
7004 double BrHXXRatio = 1.0;
7005 if (fstate == 1){
7006 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7007 } else if (fstate == 2){
7008 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7009 } else if (fstate == 3){
7010 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7011 } else if (fstate == 4){
7012 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7013 } else {
7014 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7015 }
7016
7017 if ((this->getModel()).isModelLinearized()) {
7018 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7019 } else {
7020 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7021 }
7022}
7023
7024// -----------------------------------------------------------------------------
7025
7026STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7027: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7028{
7029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7030 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7031
7032}
7033
7035{
7036 double BrHXXRatio = 1.0;
7037 if (fstate == 1){
7038 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7039 } else if (fstate == 2){
7040 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7041 } else if (fstate == 3){
7042 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7043 } else if (fstate == 4){
7044 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7045 } else {
7046 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7047 }
7048
7049 if ((this->getModel()).isModelLinearized()) {
7050 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7051 } else {
7052 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7053 }
7054}
7055
7056// -----------------------------------------------------------------------------
7057
7058STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7059: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7060{
7061 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7062 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7063
7064}
7065
7067{
7068 double BrHXXRatio = 1.0;
7069 if (fstate == 1){
7070 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7071 } else if (fstate == 2){
7072 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7073 } else if (fstate == 3){
7074 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7075 } else if (fstate == 4){
7076 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7077 } else {
7078 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7079 }
7080
7081 if ((this->getModel()).isModelLinearized()) {
7082 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7083 } else {
7084 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7085 }
7086}
7087
7088
7089// -----------------------------------------------------------------------------
7090
7091STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7092: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7093{
7094 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7095 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7096
7097}
7098
7100{
7101 //-- Production:
7102 double weight = 1.0; //If normalized to the SM
7103
7104 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7105 double muProd1 = muProd -1.0;
7106 double muProd2 = 0.0;
7107 //-- Decay:
7108 double BrHXXRatio = 1.0;
7109 double dBrHXXRatio1 = 0.0;
7110 double dBrHXXRatio2 = 0.0;
7111
7112 if (fstate == 1){
7113 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7114 dBrHXXRatio1 = BrHXXRatio - 1.0;
7115 dBrHXXRatio2 = 0.0;
7116 } else if (fstate == 2){
7117 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7118 dBrHXXRatio1 = BrHXXRatio - 1.0;
7119 dBrHXXRatio2 = 0.0;
7120 } else if (fstate == 3){
7121 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7122 dBrHXXRatio1 = BrHXXRatio - 1.0;
7123 dBrHXXRatio2 = 0.0;
7124 } else if (fstate == 4){
7125 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7126 dBrHXXRatio1 = BrHXXRatio - 1.0;
7127 dBrHXXRatio2 = 0.0;
7128 } else {
7129 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7130 }
7131
7132 //-- Production x Decay:
7133 if ((this->getModel()).isModelLinearized()){
7134 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7135 } else if((this->getModel()).isModelNPquadratic()){
7136 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7137 } else {
7138 return weight*(muProd)*(BrHXXRatio);
7139 }
7140}
7141
7142
7143
7144
7145
7146// -----------------------------------------------------------------------------
7147
7148//VM:STXS2024;
7149STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7150: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7151{
7152 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7153 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7154
7155}
7156
7158{
7159 //-- Production:
7160 double weight = 1.0; //If normalized to the SM
7161 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7162 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7163 double muProd1 = muProd -1.0;
7164 double muProd2 = 0.0;
7165
7166 //-- Decay:
7167 double BrHXXRatio = 1.0;
7168 double dBrHXXRatio1 = 0.0;
7169 double dBrHXXRatio2 = 0.0;
7170 if (fstate==0){
7171 // Use for Cross-section [pb] with no Higgs-boson decay
7172 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7173 } else if (fstate == 1){
7174 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7175 dBrHXXRatio1 = BrHXXRatio - 1.0;
7176 dBrHXXRatio2 = 0.0;
7177 } else if (fstate == 2){
7178 BrHXXRatio = (myNPbase->BrHgagaRatio());
7179 dBrHXXRatio1 = BrHXXRatio - 1.0;
7180 dBrHXXRatio2 = 0.0;
7181 } else if (fstate == 3){
7182 BrHXXRatio = (myNPbase->BrHbbRatio());
7183 dBrHXXRatio1 = BrHXXRatio - 1.0;
7184 dBrHXXRatio2 = 0.0;
7185 } else if (fstate == 4){
7186 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7187 dBrHXXRatio1 = BrHXXRatio - 1.0;
7188 dBrHXXRatio2 = 0.0;
7189 } else if (fstate == 5){
7190 BrHXXRatio = (myNPbase->BrHtautauRatio());
7191 dBrHXXRatio1 = BrHXXRatio - 1.0;
7192 dBrHXXRatio2 = 0.0;
7193 } else if (fstate == 6){
7194 BrHXXRatio = (myNPbase->BrHWWRatio());
7195 dBrHXXRatio1 = BrHXXRatio - 1.0;
7196 dBrHXXRatio2 = 0.0;
7197 } else if (fstate == 7){
7198 BrHXXRatio = (myNPbase->BrHZZRatio());
7199 dBrHXXRatio1 = BrHXXRatio - 1.0;
7200 dBrHXXRatio2 = 0.0;
7201 } else {
7202 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7203 }
7204
7205 //-- Production x Decay:
7206 if ((this->getModel()).isModelLinearized()){
7207 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7208 } else if((this->getModel()).isModelNPquadratic()){
7209 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7210 } else {
7211 return weight*(muProd)*(BrHXXRatio);
7212 }
7213
7214}
7215
7216
7217
7218// -----------------------------------------------------------------------------
7219
7220//VM:STXS2024;
7221STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7222: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7223{
7224 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7225 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7226
7227}
7228
7230{
7231 //-- Production:
7232 double weight = 1.0; //If normalized to the SM
7233 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7234 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7235 double muProd1 = muProd -1.0;
7236 double muProd2 = 0.0;
7237
7238 //-- Decay:
7239 double BrHXXRatio = 1.0;
7240 double dBrHXXRatio1 = 0.0;
7241 double dBrHXXRatio2 = 0.0;
7242 if (fstate==0){
7243 // Use for Cross-section [pb] with no Higgs-boson decay
7244 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7245 } else if (fstate == 1){
7246 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7247 dBrHXXRatio1 = BrHXXRatio - 1.0;
7248 dBrHXXRatio2 = 0.0;
7249 } else if (fstate == 2){
7250 BrHXXRatio = (myNPbase->BrHgagaRatio());
7251 dBrHXXRatio1 = BrHXXRatio - 1.0;
7252 dBrHXXRatio2 = 0.0;
7253 } else if (fstate == 3){
7254 BrHXXRatio = (myNPbase->BrHbbRatio());
7255 dBrHXXRatio1 = BrHXXRatio - 1.0;
7256 dBrHXXRatio2 = 0.0;
7257 } else if (fstate == 4){
7258 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7259 dBrHXXRatio1 = BrHXXRatio - 1.0;
7260 dBrHXXRatio2 = 0.0;
7261 } else if (fstate == 5){
7262 BrHXXRatio = (myNPbase->BrHtautauRatio());
7263 dBrHXXRatio1 = BrHXXRatio - 1.0;
7264 dBrHXXRatio2 = 0.0;
7265 } else if (fstate == 6){
7266 BrHXXRatio = (myNPbase->BrHWWRatio());
7267 dBrHXXRatio1 = BrHXXRatio - 1.0;
7268 dBrHXXRatio2 = 0.0;
7269 } else if (fstate == 7){
7270 BrHXXRatio = (myNPbase->BrHZZRatio());
7271 dBrHXXRatio1 = BrHXXRatio - 1.0;
7272 dBrHXXRatio2 = 0.0;
7273 } else {
7274 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7275 }
7276
7277 //-- Production x Decay:
7278 if ((this->getModel()).isModelLinearized()){
7279 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7280 } else if((this->getModel()).isModelNPquadratic()){
7281 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7282 } else {
7283 return weight*(muProd)*(BrHXXRatio);
7284 }
7285
7286}
7287
7288
7289
7290
7291// -----------------------------------------------------------------------------
7292
7293//VM:STXS2024;
7294STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7295: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7296{
7297 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7298 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7299
7300}
7301
7303{
7304 //-- Production:
7305 double weight = 1.0; //If normalized to the SM
7306 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7307 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7309 /(6.6369 + 20.642);
7310 double muProd1 = muProd -1.0;
7311 double muProd2 = 0.0;
7312
7313 //-- Decay:
7314 double BrHXXRatio = 1.0;
7315 double dBrHXXRatio1 = 0.0;
7316 double dBrHXXRatio2 = 0.0;
7317 if (fstate==0){
7318 // Use for Cross-section [pb] with no Higgs-boson decay
7319 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7320 } else if (fstate == 1){
7321 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7322 dBrHXXRatio1 = BrHXXRatio - 1.0;
7323 dBrHXXRatio2 = 0.0;
7324 } else if (fstate == 2){
7325 BrHXXRatio = (myNPbase->BrHgagaRatio());
7326 dBrHXXRatio1 = BrHXXRatio - 1.0;
7327 dBrHXXRatio2 = 0.0;
7328 } else if (fstate == 3){
7329 BrHXXRatio = (myNPbase->BrHbbRatio());
7330 dBrHXXRatio1 = BrHXXRatio - 1.0;
7331 dBrHXXRatio2 = 0.0;
7332 } else if (fstate == 4){
7333 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7334 dBrHXXRatio1 = BrHXXRatio - 1.0;
7335 dBrHXXRatio2 = 0.0;
7336 } else if (fstate == 5){
7337 BrHXXRatio = (myNPbase->BrHtautauRatio());
7338 dBrHXXRatio1 = BrHXXRatio - 1.0;
7339 dBrHXXRatio2 = 0.0;
7340 } else if (fstate == 6){
7341 BrHXXRatio = (myNPbase->BrHWWRatio());
7342 dBrHXXRatio1 = BrHXXRatio - 1.0;
7343 dBrHXXRatio2 = 0.0;
7344 } else if (fstate == 7){
7345 BrHXXRatio = (myNPbase->BrHZZRatio());
7346 dBrHXXRatio1 = BrHXXRatio - 1.0;
7347 dBrHXXRatio2 = 0.0;
7348 } else {
7349 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7350 }
7351
7352 //-- Production x Decay:
7353 if ((this->getModel()).isModelLinearized()){
7354 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7355 } else if((this->getModel()).isModelNPquadratic()){
7356 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7357 } else {
7358 return weight*(muProd)*(BrHXXRatio);
7359 }
7360
7361}
7362
7363
7364
7365
7366// -----------------------------------------------------------------------------
7367
7368//VM:STXS2024;
7369STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7370: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7371{
7372 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7373 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7374
7375}
7376
7378{
7379 //-- Production:
7380 double weight = 1.0; //If normalized to the SM
7381 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7382
7383 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7384 double muProd1 = muProd -1.0;
7385 double muProd2 = 0.0;
7386
7387 //-- Decay:
7388 double BrHXXRatio = 1.0;
7389 double dBrHXXRatio1 = 0.0;
7390 double dBrHXXRatio2 = 0.0;
7391 if (fstate==0){
7392 // Use for Cross-section [pb] with no Higgs-boson decay
7393 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7394 } else if (fstate == 1){
7395 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7396 dBrHXXRatio1 = BrHXXRatio - 1.0;
7397 dBrHXXRatio2 = 0.0;
7398 } else if (fstate == 2){
7399 BrHXXRatio = (myNPbase->BrHgagaRatio());
7400 dBrHXXRatio1 = BrHXXRatio - 1.0;
7401 dBrHXXRatio2 = 0.0;
7402 } else if (fstate == 3){
7403 BrHXXRatio = (myNPbase->BrHbbRatio());
7404 dBrHXXRatio1 = BrHXXRatio - 1.0;
7405 dBrHXXRatio2 = 0.0;
7406 } else if (fstate == 4){
7407 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7408 dBrHXXRatio1 = BrHXXRatio - 1.0;
7409 dBrHXXRatio2 = 0.0;
7410 } else if (fstate == 5){
7411 BrHXXRatio = (myNPbase->BrHtautauRatio());
7412 dBrHXXRatio1 = BrHXXRatio - 1.0;
7413 dBrHXXRatio2 = 0.0;
7414 } else if (fstate == 6){
7415 BrHXXRatio = (myNPbase->BrHWWRatio());
7416 dBrHXXRatio1 = BrHXXRatio - 1.0;
7417 dBrHXXRatio2 = 0.0;
7418 } else if (fstate == 7){
7419 BrHXXRatio = (myNPbase->BrHZZRatio());
7420 dBrHXXRatio1 = BrHXXRatio - 1.0;
7421 dBrHXXRatio2 = 0.0;
7422 } else {
7423 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7424 }
7425
7426 //-- Production x Decay:
7427 if ((this->getModel()).isModelLinearized()){
7428 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7429 } else if((this->getModel()).isModelNPquadratic()){
7430 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7431 } else {
7432 return weight*(muProd)*(BrHXXRatio);
7433 }
7434
7435}
7436
7437
7438
7439
7440
7441
7442
7443// -----------------------------------------------------------------------------
7444
7445//AG:STXS2024
7446STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7447: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7448{
7449 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7450 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7451
7452}
7453
7455{
7456 //-- Production:
7457 double weight = 1.0; //If normalized to the SM
7458 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7459 double muProd1 = muProd -1.0;
7460 double muProd2 = 0.0;
7461
7462 //-- Decay:
7463 double BrHXXRatio = 1.0;
7464 double dBrHXXRatio1 = 0.0;
7465 double dBrHXXRatio2 = 0.0;
7466 if (fstate==0){
7467 // Use for Cross-section [pb] with no Higgs-boson decay
7468 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7469 } else if (fstate == 1){
7470 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7471 dBrHXXRatio1 = BrHXXRatio - 1.0;
7472 dBrHXXRatio2 = 0.0;
7473 } else if (fstate == 2){
7474 BrHXXRatio = (myNPbase->BrHgagaRatio());
7475 dBrHXXRatio1 = BrHXXRatio - 1.0;
7476 dBrHXXRatio2 = 0.0;
7477 } else if (fstate == 3){
7478 BrHXXRatio = (myNPbase->BrHbbRatio());
7479 dBrHXXRatio1 = BrHXXRatio - 1.0;
7480 dBrHXXRatio2 = 0.0;
7481 } else if (fstate == 4){
7482 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7483 dBrHXXRatio1 = BrHXXRatio - 1.0;
7484 dBrHXXRatio2 = 0.0;
7485 } else if (fstate == 5){
7486 BrHXXRatio = (myNPbase->BrHtautauRatio());
7487 dBrHXXRatio1 = BrHXXRatio - 1.0;
7488 dBrHXXRatio2 = 0.0;
7489 } else if (fstate == 6){
7490 BrHXXRatio = (myNPbase->BrHWWRatio());
7491 dBrHXXRatio1 = BrHXXRatio - 1.0;
7492 dBrHXXRatio2 = 0.0;
7493 } else if (fstate == 7){
7494 BrHXXRatio = (myNPbase->BrHZZRatio());
7495 dBrHXXRatio1 = BrHXXRatio - 1.0;
7496 dBrHXXRatio2 = 0.0;
7497 } else {
7498 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7499 }
7500
7501 //-- Production x Decay:
7502 if ((this->getModel()).isModelLinearized()){
7503 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7504 } else if((this->getModel()).isModelNPquadratic()){
7505 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7506 } else {
7507 return weight*(muProd)*(BrHXXRatio);
7508 }
7509
7510}
7511
7512// -----------------------------------------------------------------------------
7513
7514//AG:STXS2024
7515STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7516: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7517{
7518 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7519 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7520
7521}
7522
7524{
7525 //-- Production:
7526 double weight = 1.0; //If normalized to the SM
7527 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7528 double muProd1 = muProd -1.0;
7529 double muProd2 = 0.0;
7530
7531 //-- Decay:
7532 double BrHXXRatio = 1.0;
7533 double dBrHXXRatio1 = 0.0;
7534 double dBrHXXRatio2 = 0.0;
7535 if (fstate==0){
7536 // Use for Cross-section [pb] with no Higgs-boson decay
7537 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7538 } else if (fstate == 1){
7539 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7540 dBrHXXRatio1 = BrHXXRatio - 1.0;
7541 dBrHXXRatio2 = 0.0;
7542 } else if (fstate == 2){
7543 BrHXXRatio = (myNPbase->BrHgagaRatio());
7544 dBrHXXRatio1 = BrHXXRatio - 1.0;
7545 dBrHXXRatio2 = 0.0;
7546 } else if (fstate == 3){
7547 BrHXXRatio = (myNPbase->BrHbbRatio());
7548 dBrHXXRatio1 = BrHXXRatio - 1.0;
7549 dBrHXXRatio2 = 0.0;
7550 } else if (fstate == 4){
7551 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7552 dBrHXXRatio1 = BrHXXRatio - 1.0;
7553 dBrHXXRatio2 = 0.0;
7554 } else if (fstate == 5){
7555 BrHXXRatio = (myNPbase->BrHtautauRatio());
7556 dBrHXXRatio1 = BrHXXRatio - 1.0;
7557 dBrHXXRatio2 = 0.0;
7558 } else if (fstate == 6){
7559 BrHXXRatio = (myNPbase->BrHWWRatio());
7560 dBrHXXRatio1 = BrHXXRatio - 1.0;
7561 dBrHXXRatio2 = 0.0;
7562 } else if (fstate == 7){
7563 BrHXXRatio = (myNPbase->BrHZZRatio());
7564 dBrHXXRatio1 = BrHXXRatio - 1.0;
7565 dBrHXXRatio2 = 0.0;
7566 } else {
7567 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7568 }
7569
7570 //-- Production x Decay:
7571 if ((this->getModel()).isModelLinearized()){
7572 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7573 } else if((this->getModel()).isModelNPquadratic()){
7574 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7575 } else {
7576 return weight*(muProd)*(BrHXXRatio);
7577 }
7578
7579}
7580
7581// -----------------------------------------------------------------------------
7582
7583//AG:STXS2024
7584STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7585: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7586{
7587 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7588 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7589
7590}
7591
7593{
7594 //-- Production:
7595 double weight = 1.0; //If normalized to the SM
7596 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7597 double muProd1 = muProd -1.0;
7598 double muProd2 = 0.0;
7599
7600 //-- Decay:
7601 double BrHXXRatio = 1.0;
7602 double dBrHXXRatio1 = 0.0;
7603 double dBrHXXRatio2 = 0.0;
7604 if (fstate==0){
7605 // Use for Cross-section [pb] with no Higgs-boson decay
7606 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7607 } else if (fstate == 1){
7608 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7609 dBrHXXRatio1 = BrHXXRatio - 1.0;
7610 dBrHXXRatio2 = 0.0;
7611 } else if (fstate == 2){
7612 BrHXXRatio = (myNPbase->BrHgagaRatio());
7613 dBrHXXRatio1 = BrHXXRatio - 1.0;
7614 dBrHXXRatio2 = 0.0;
7615 } else if (fstate == 3){
7616 BrHXXRatio = (myNPbase->BrHbbRatio());
7617 dBrHXXRatio1 = BrHXXRatio - 1.0;
7618 dBrHXXRatio2 = 0.0;
7619 } else if (fstate == 4){
7620 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7621 dBrHXXRatio1 = BrHXXRatio - 1.0;
7622 dBrHXXRatio2 = 0.0;
7623 } else if (fstate == 5){
7624 BrHXXRatio = (myNPbase->BrHtautauRatio());
7625 dBrHXXRatio1 = BrHXXRatio - 1.0;
7626 dBrHXXRatio2 = 0.0;
7627 } else if (fstate == 6){
7628 BrHXXRatio = (myNPbase->BrHWWRatio());
7629 dBrHXXRatio1 = BrHXXRatio - 1.0;
7630 dBrHXXRatio2 = 0.0;
7631 } else if (fstate == 7){
7632 BrHXXRatio = (myNPbase->BrHZZRatio());
7633 dBrHXXRatio1 = BrHXXRatio - 1.0;
7634 dBrHXXRatio2 = 0.0;
7635 } else {
7636 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7637 }
7638
7639 //-- Production x Decay:
7640 if ((this->getModel()).isModelLinearized()){
7641 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7642 } else if((this->getModel()).isModelNPquadratic()){
7643 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7644 } else {
7645 return weight*(muProd)*(BrHXXRatio);
7646 }
7647
7648}
7649
7650// -----------------------------------------------------------------------------
7651
7652STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7653: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7654{
7655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7656 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7657
7658}
7659
7661{
7662 double BrHXXRatio = 1.0;
7663 if (fstate == 1){
7664 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7665 } else if (fstate == 2){
7666 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7667 } else if (fstate == 3){
7668 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7669 } else if (fstate == 4){
7670 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7671 } else {
7672 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7673 }
7674
7675 if ((this->getModel()).isModelLinearized()) {
7676 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7677 } else {
7678 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7679 }
7680}
7681
7682// -----------------------------------------------------------------------------
7683
7684STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7685: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7686{
7687 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7688 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7689
7690}
7691
7693{
7694 double BrHXXRatio = 1.0;
7695 if (fstate == 1){
7696 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7697 } else if (fstate == 2){
7698 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7699 } else if (fstate == 3){
7700 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7701 } else if (fstate == 4){
7702 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7703 } else {
7704 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7705 }
7706
7707 if ((this->getModel()).isModelLinearized()) {
7708 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7709 } else {
7710 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7711 }
7712}
7713
7714
7715
7716
7717
7718// -----------------------------------------------------------------------------
7719
7720//VM:STXS2024;
7721STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7722: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7723{
7724 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7725 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7726
7727}
7728
7730{
7731 //-- Production:
7732 double weight = 1.0; //If normalized to the SM
7733 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7734 //We should weight each xsection with the SM prediction. We need to check
7735 //this values, nevertheless, the difference between the two parametrisations
7736 //is extremely small (way beyond our current precision)
7737 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7739 /(2.);
7740 double muProd1 = muProd -1.0;
7741 double muProd2 = 0.0;
7742
7743 //-- Decay:
7744 double BrHXXRatio = 1.0;
7745 double dBrHXXRatio1 = 0.0;
7746 double dBrHXXRatio2 = 0.0;
7747 if (fstate==0){
7748 // Use for Cross-section [pb] with no Higgs-boson decay
7749 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7750 } else if (fstate == 1){
7751 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7752 dBrHXXRatio1 = BrHXXRatio - 1.0;
7753 dBrHXXRatio2 = 0.0;
7754 } else if (fstate == 2){
7755 BrHXXRatio = (myNPbase->BrHgagaRatio());
7756 dBrHXXRatio1 = BrHXXRatio - 1.0;
7757 dBrHXXRatio2 = 0.0;
7758 } else if (fstate == 3){
7759 BrHXXRatio = (myNPbase->BrHbbRatio());
7760 dBrHXXRatio1 = BrHXXRatio - 1.0;
7761 dBrHXXRatio2 = 0.0;
7762 } else if (fstate == 4){
7763 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7764 dBrHXXRatio1 = BrHXXRatio - 1.0;
7765 dBrHXXRatio2 = 0.0;
7766 } else if (fstate == 5){
7767 BrHXXRatio = (myNPbase->BrHtautauRatio());
7768 dBrHXXRatio1 = BrHXXRatio - 1.0;
7769 dBrHXXRatio2 = 0.0;
7770 } else if (fstate == 6){
7771 BrHXXRatio = (myNPbase->BrHWWRatio());
7772 dBrHXXRatio1 = BrHXXRatio - 1.0;
7773 dBrHXXRatio2 = 0.0;
7774 } else if (fstate == 7){
7775 BrHXXRatio = (myNPbase->BrHZZRatio());
7776 dBrHXXRatio1 = BrHXXRatio - 1.0;
7777 dBrHXXRatio2 = 0.0;
7778 } else {
7779 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7780 }
7781
7782 //-- Production x Decay:
7783 if ((this->getModel()).isModelLinearized()){
7784 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7785 } else if((this->getModel()).isModelNPquadratic()){
7786 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7787 } else {
7788 return weight*(muProd)*(BrHXXRatio);
7789 }
7790
7791}
7792
7793
7794
7795
7796// -----------------------------------------------------------------------------
7797
7798//AG:STXS2024
7799STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7800: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7801{
7802 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7803 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7804
7805}
7806
7808{
7809 //-- Production:
7810 double weight = 1.0; //If normalized to the SM
7812 double muProd1 = muProd -1.0;
7813 double muProd2 = 0.0;
7814
7815 //-- Decay:
7816 double BrHXXRatio = 1.0;
7817 double dBrHXXRatio1 = 0.0;
7818 double dBrHXXRatio2 = 0.0;
7819 if (fstate==0){
7820 // Use for Cross-section [pb] with no Higgs-boson decay
7821 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7822 } else if (fstate == 1){
7823 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7824 dBrHXXRatio1 = BrHXXRatio - 1.0;
7825 dBrHXXRatio2 = 0.0;
7826 } else if (fstate == 2){
7827 BrHXXRatio = (myNPbase->BrHgagaRatio());
7828 dBrHXXRatio1 = BrHXXRatio - 1.0;
7829 dBrHXXRatio2 = 0.0;
7830 } else if (fstate == 3){
7831 BrHXXRatio = (myNPbase->BrHbbRatio());
7832 dBrHXXRatio1 = BrHXXRatio - 1.0;
7833 dBrHXXRatio2 = 0.0;
7834 } else if (fstate == 4){
7835 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7836 dBrHXXRatio1 = BrHXXRatio - 1.0;
7837 dBrHXXRatio2 = 0.0;
7838 } else if (fstate == 5){
7839 BrHXXRatio = (myNPbase->BrHtautauRatio());
7840 dBrHXXRatio1 = BrHXXRatio - 1.0;
7841 dBrHXXRatio2 = 0.0;
7842 }else {
7843 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7844 }
7845
7846 //-- Production x Decay:
7847 if ((this->getModel()).isModelLinearized()){
7848 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7849 } else if((this->getModel()).isModelNPquadratic()){
7850 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7851 } else {
7852 return weight*(muProd)*(BrHXXRatio);
7853 }
7854
7855}
7856
7857
7858
7859
7860//VM:STXS2024;
7861STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7862: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7863{
7864 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7865 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7866
7867}
7868
7870{
7871 //-- Production:
7872 double weight = 1.0; //If normalized to the SM
7873 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7874 //We should weight each xsection with the SM prediction. We need to check
7875 //this values, nevertheless, the difference between the two parametrisations
7876 //is extremely small (way beyond our current precision)
7879 /(2.);
7880 double muProd1 = muProd -1.0;
7881 double muProd2 = 0.0;
7882
7883 //-- Decay:
7884 double BrHXXRatio = 1.0;
7885 double dBrHXXRatio1 = 0.0;
7886 double dBrHXXRatio2 = 0.0;
7887 if (fstate==0){
7888 // Use for Cross-section [pb] with no Higgs-boson decay
7889 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7890 } else if (fstate == 1){
7891 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7892 dBrHXXRatio1 = BrHXXRatio - 1.0;
7893 dBrHXXRatio2 = 0.0;
7894 } else if (fstate == 2){
7895 BrHXXRatio = (myNPbase->BrHgagaRatio());
7896 dBrHXXRatio1 = BrHXXRatio - 1.0;
7897 dBrHXXRatio2 = 0.0;
7898 } else if (fstate == 3){
7899 BrHXXRatio = (myNPbase->BrHbbRatio());
7900 dBrHXXRatio1 = BrHXXRatio - 1.0;
7901 dBrHXXRatio2 = 0.0;
7902 } else if (fstate == 4){
7903 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7904 dBrHXXRatio1 = BrHXXRatio - 1.0;
7905 dBrHXXRatio2 = 0.0;
7906 } else if (fstate == 5){
7907 BrHXXRatio = (myNPbase->BrHtautauRatio());
7908 dBrHXXRatio1 = BrHXXRatio - 1.0;
7909 dBrHXXRatio2 = 0.0;
7910 } else if (fstate == 6){
7911 BrHXXRatio = (myNPbase->BrHWWRatio());
7912 dBrHXXRatio1 = BrHXXRatio - 1.0;
7913 dBrHXXRatio2 = 0.0;
7914 } else if (fstate == 7){
7915 BrHXXRatio = (myNPbase->BrHZZRatio());
7916 dBrHXXRatio1 = BrHXXRatio - 1.0;
7917 dBrHXXRatio2 = 0.0;
7918 } else {
7919 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7920 }
7921
7922 //-- Production x Decay:
7923 if ((this->getModel()).isModelLinearized()){
7924 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7925 } else if((this->getModel()).isModelNPquadratic()){
7926 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7927 } else {
7928 return weight*(muProd)*(BrHXXRatio);
7929 }
7930
7931}
7932
7933
7934// -----------------------------------------------------------------------------
7935
7937: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7938{
7939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7940 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
7941
7942}
7943
7945{
7946 double BrHXXRatio = 1.0;
7947 if (fstate == 1){
7948 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7949 } else if (fstate == 2){
7950 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7951 } else if (fstate == 3){
7952 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7953 } else if (fstate == 4){
7954 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7955 } else {
7956 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
7957 }
7958
7959 if ((this->getModel()).isModelLinearized()) {
7960 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7961 } else {
7963 }
7964}
7965
7966// -----------------------------------------------------------------------------
7967
7969: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7970{
7971
7972 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7973 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
7974
7975}
7976
7978{
7979 double BrHXXRatio = 1.0;
7980 if (fstate == 1){
7981 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7982 } else if (fstate == 2){
7983 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7984 } else if (fstate == 3){
7985 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7986 } else if (fstate == 4){
7987 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7988 } else {
7989 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
7990 }
7991
7992 if ((this->getModel()).isModelLinearized()) {
7993 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7994 } else {
7996 }
7997}
7998
7999// -----------------------------------------------------------------------------
8000
8002: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8003{
8004 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8005 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8006
8007}
8008
8010{
8011 double BrHXXRatio = 1.0;
8012 if (fstate == 1){
8013 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8014 } else if (fstate == 2){
8015 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8016 } else if (fstate == 3){
8017 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8018 } else if (fstate == 4){
8019 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8020 } else {
8021 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8022 }
8023
8024 if ((this->getModel()).isModelLinearized()) {
8025 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8026 } else {
8028 }
8029}
8030
8031// -----------------------------------------------------------------------------
8032
8034: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8035{
8036 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8037 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8038
8039}
8040
8042{
8043 double BrHXXRatio = 1.0;
8044 if (fstate == 1){
8045 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8046 } else if (fstate == 2){
8047 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8048 } else if (fstate == 3){
8049 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8050 } else if (fstate == 4){
8051 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8052 } else {
8053 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8054 }
8055
8056 if ((this->getModel()).isModelLinearized()) {
8057 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8058 } else {
8060 }
8061}
8062
8063
8064
8065
8066
8067// -----------------------------------------------------------------------------
8068
8069//VM:STXS2024;
8070STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8071: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8072{
8073 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8074 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8075
8076}
8077
8079{
8080
8081
8082
8083 //-- Production:
8084 double weight = 1.0; //If normalized to the SM
8085 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8086 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8087 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8088 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8089 //The possible error that we could be introducing here is way below our precision!
8090 double muProd = (
8094 )/(2.9636+0.94321+0.87751);
8095 double muProd1 = muProd -1.0;
8096 double muProd2 = 0.0;
8097
8098 //-- Decay:
8099 double BrHXXRatio = 1.0;
8100 double dBrHXXRatio1 = 0.0;
8101 double dBrHXXRatio2 = 0.0;
8102 if (fstate==0){
8103 // Use for Cross-section [pb] with no Higgs-boson decay
8104 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8105 } else if (fstate == 1){
8106 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8107 dBrHXXRatio1 = BrHXXRatio - 1.0;
8108 dBrHXXRatio2 = 0.0;
8109 } else if (fstate == 2){
8110 BrHXXRatio = (myNPbase->BrHgagaRatio());
8111 dBrHXXRatio1 = BrHXXRatio - 1.0;
8112 dBrHXXRatio2 = 0.0;
8113 } else if (fstate == 3){
8114 BrHXXRatio = (myNPbase->BrHbbRatio());
8115 dBrHXXRatio1 = BrHXXRatio - 1.0;
8116 dBrHXXRatio2 = 0.0;
8117 } else if (fstate == 4){
8118 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8119 dBrHXXRatio1 = BrHXXRatio - 1.0;
8120 dBrHXXRatio2 = 0.0;
8121 } else if (fstate == 5){
8122 BrHXXRatio = (myNPbase->BrHtautauRatio());
8123 dBrHXXRatio1 = BrHXXRatio - 1.0;
8124 dBrHXXRatio2 = 0.0;
8125 } else if (fstate == 6){
8126 BrHXXRatio = (myNPbase->BrHWWRatio());
8127 dBrHXXRatio1 = BrHXXRatio - 1.0;
8128 dBrHXXRatio2 = 0.0;
8129 } else if (fstate == 7){
8130 BrHXXRatio = (myNPbase->BrHZZRatio());
8131 dBrHXXRatio1 = BrHXXRatio - 1.0;
8132 dBrHXXRatio2 = 0.0;
8133 } else {
8134 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8135 }
8136
8137 //-- Production x Decay:
8138 if ((this->getModel()).isModelLinearized()){
8139 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8140 } else if((this->getModel()).isModelNPquadratic()){
8141 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8142 } else {
8143 return weight*(muProd)*(BrHXXRatio);
8144 }
8145
8146}
8147
8148
8149
8150
8151
8152
8153
8154// -----------------------------------------------------------------------------
8155
8156
8157//VM:STXS2024;
8158STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8159: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8160{
8161 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8162 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8163
8164}
8165
8167{
8168 //-- Production:
8169 double weight = 1.0; //If normalized to the SM
8170 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8171 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8174 /(0.45825 + 0.10632 + 0.017974);
8175 double muProd1 = muProd -1.0;
8176 double muProd2 = 0.0;
8177
8178 //-- Decay:
8179 double BrHXXRatio = 1.0;
8180 double dBrHXXRatio1 = 0.0;
8181 double dBrHXXRatio2 = 0.0;
8182 if (fstate==0){
8183 // Use for Cross-section [pb] with no Higgs-boson decay
8184 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8185 } else if (fstate == 1){
8186 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8187 dBrHXXRatio1 = BrHXXRatio - 1.0;
8188 dBrHXXRatio2 = 0.0;
8189 } else if (fstate == 2){
8190 BrHXXRatio = (myNPbase->BrHgagaRatio());
8191 dBrHXXRatio1 = BrHXXRatio - 1.0;
8192 dBrHXXRatio2 = 0.0;
8193 } else if (fstate == 3){
8194 BrHXXRatio = (myNPbase->BrHbbRatio());
8195 dBrHXXRatio1 = BrHXXRatio - 1.0;
8196 dBrHXXRatio2 = 0.0;
8197 } else if (fstate == 4){
8198 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8199 dBrHXXRatio1 = BrHXXRatio - 1.0;
8200 dBrHXXRatio2 = 0.0;
8201 } else if (fstate == 5){
8202 BrHXXRatio = (myNPbase->BrHtautauRatio());
8203 dBrHXXRatio1 = BrHXXRatio - 1.0;
8204 dBrHXXRatio2 = 0.0;
8205 } else if (fstate == 6){
8206 BrHXXRatio = (myNPbase->BrHWWRatio());
8207 dBrHXXRatio1 = BrHXXRatio - 1.0;
8208 dBrHXXRatio2 = 0.0;
8209 } else if (fstate == 7){
8210 BrHXXRatio = (myNPbase->BrHZZRatio());
8211 dBrHXXRatio1 = BrHXXRatio - 1.0;
8212 dBrHXXRatio2 = 0.0;
8213 } else {
8214 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8215 }
8216
8217 //-- Production x Decay:
8218 if ((this->getModel()).isModelLinearized()){
8219 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8220 } else if((this->getModel()).isModelNPquadratic()){
8221 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8222 } else {
8223 return weight*(muProd)*(BrHXXRatio);
8224 }
8225
8226}
8227
8228
8229
8230
8231// -----------------------------------------------------------------------------
8232
8233
8234//VM:STXS2024;
8235STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8236: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8237{
8238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8239 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8240
8241}
8242
8244{
8245 //-- Production:
8246 double weight = 1.0; //If normalized to the SM
8247 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8248 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8250 /(0.10632 + 0.017974);
8251 double muProd1 = muProd -1.0;
8252 double muProd2 = 0.0;
8253
8254 //-- Decay:
8255 double BrHXXRatio = 1.0;
8256 double dBrHXXRatio1 = 0.0;
8257 double dBrHXXRatio2 = 0.0;
8258 if (fstate==0){
8259 // Use for Cross-section [pb] with no Higgs-boson decay
8260 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8261 } else if (fstate == 1){
8262 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8263 dBrHXXRatio1 = BrHXXRatio - 1.0;
8264 dBrHXXRatio2 = 0.0;
8265 } else if (fstate == 2){
8266 BrHXXRatio = (myNPbase->BrHgagaRatio());
8267 dBrHXXRatio1 = BrHXXRatio - 1.0;
8268 dBrHXXRatio2 = 0.0;
8269 } else if (fstate == 3){
8270 BrHXXRatio = (myNPbase->BrHbbRatio());
8271 dBrHXXRatio1 = BrHXXRatio - 1.0;
8272 dBrHXXRatio2 = 0.0;
8273 } else if (fstate == 4){
8274 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8275 dBrHXXRatio1 = BrHXXRatio - 1.0;
8276 dBrHXXRatio2 = 0.0;
8277 } else if (fstate == 5){
8278 BrHXXRatio = (myNPbase->BrHtautauRatio());
8279 dBrHXXRatio1 = BrHXXRatio - 1.0;
8280 dBrHXXRatio2 = 0.0;
8281 } else if (fstate == 6){
8282 BrHXXRatio = (myNPbase->BrHWWRatio());
8283 dBrHXXRatio1 = BrHXXRatio - 1.0;
8284 dBrHXXRatio2 = 0.0;
8285 } else if (fstate == 7){
8286 BrHXXRatio = (myNPbase->BrHZZRatio());
8287 dBrHXXRatio1 = BrHXXRatio - 1.0;
8288 dBrHXXRatio2 = 0.0;
8289 } else {
8290 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8291 }
8292
8293 //-- Production x Decay:
8294 if ((this->getModel()).isModelLinearized()){
8295 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8296 } else if((this->getModel()).isModelNPquadratic()){
8297 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8298 } else {
8299 return weight*(muProd)*(BrHXXRatio);
8300 }
8301
8302}
8303
8304
8305// -----------------------------------------------------------------------------
8306
8307
8308//VM:STXS2024;
8309STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8310: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8311{
8312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8313 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8314
8315}
8316
8318{
8319 //-- Production:
8320 double weight = 1.0; //If normalized to the SM
8321 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8322 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8323 double muProd1 = muProd -1.0;
8324 double muProd2 = 0.0;
8325
8326 //-- Decay:
8327 double BrHXXRatio = 1.0;
8328 double dBrHXXRatio1 = 0.0;
8329 double dBrHXXRatio2 = 0.0;
8330 if (fstate==0){
8331 // Use for Cross-section [pb] with no Higgs-boson decay
8332 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8333 } else if (fstate == 1){
8334 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8335 dBrHXXRatio1 = BrHXXRatio - 1.0;
8336 dBrHXXRatio2 = 0.0;
8337 } else if (fstate == 2){
8338 BrHXXRatio = (myNPbase->BrHgagaRatio());
8339 dBrHXXRatio1 = BrHXXRatio - 1.0;
8340 dBrHXXRatio2 = 0.0;
8341 } else if (fstate == 3){
8342 BrHXXRatio = (myNPbase->BrHbbRatio());
8343 dBrHXXRatio1 = BrHXXRatio - 1.0;
8344 dBrHXXRatio2 = 0.0;
8345 } else if (fstate == 4){
8346 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8347 dBrHXXRatio1 = BrHXXRatio - 1.0;
8348 dBrHXXRatio2 = 0.0;
8349 } else if (fstate == 5){
8350 BrHXXRatio = (myNPbase->BrHtautauRatio());
8351 dBrHXXRatio1 = BrHXXRatio - 1.0;
8352 dBrHXXRatio2 = 0.0;
8353 } else if (fstate == 6){
8354 BrHXXRatio = (myNPbase->BrHWWRatio());
8355 dBrHXXRatio1 = BrHXXRatio - 1.0;
8356 dBrHXXRatio2 = 0.0;
8357 } else if (fstate == 7){
8358 BrHXXRatio = (myNPbase->BrHZZRatio());
8359 dBrHXXRatio1 = BrHXXRatio - 1.0;
8360 dBrHXXRatio2 = 0.0;
8361 } else {
8362 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8363 }
8364
8365 //-- Production x Decay:
8366 if ((this->getModel()).isModelLinearized()){
8367 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8368 } else if((this->getModel()).isModelNPquadratic()){
8369 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8370 } else {
8371 return weight*(muProd)*(BrHXXRatio);
8372 }
8373
8374}
8375
8376
8377
8378// -----------------------------------------------------------------------------
8379
8380
8381//VM:STXS2024;
8382STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8383: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8384{
8385 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8386 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8387
8388}
8389
8391{
8392 //-- Production:
8393 double weight = 1.0; //If normalized to the SM
8394 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8395 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8396 double muProd1 = muProd -1.0;
8397 double muProd2 = 0.0;
8398
8399 //-- Decay:
8400 double BrHXXRatio = 1.0;
8401 double dBrHXXRatio1 = 0.0;
8402 double dBrHXXRatio2 = 0.0;
8403 if (fstate==0){
8404 // Use for Cross-section [pb] with no Higgs-boson decay
8405 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8406 } else if (fstate == 1){
8407 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8408 dBrHXXRatio1 = BrHXXRatio - 1.0;
8409 dBrHXXRatio2 = 0.0;
8410 } else if (fstate == 2){
8411 BrHXXRatio = (myNPbase->BrHgagaRatio());
8412 dBrHXXRatio1 = BrHXXRatio - 1.0;
8413 dBrHXXRatio2 = 0.0;
8414 } else if (fstate == 3){
8415 BrHXXRatio = (myNPbase->BrHbbRatio());
8416 dBrHXXRatio1 = BrHXXRatio - 1.0;
8417 dBrHXXRatio2 = 0.0;
8418 } else if (fstate == 4){
8419 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8420 dBrHXXRatio1 = BrHXXRatio - 1.0;
8421 dBrHXXRatio2 = 0.0;
8422 } else if (fstate == 5){
8423 BrHXXRatio = (myNPbase->BrHtautauRatio());
8424 dBrHXXRatio1 = BrHXXRatio - 1.0;
8425 dBrHXXRatio2 = 0.0;
8426 } else if (fstate == 6){
8427 BrHXXRatio = (myNPbase->BrHWWRatio());
8428 dBrHXXRatio1 = BrHXXRatio - 1.0;
8429 dBrHXXRatio2 = 0.0;
8430 } else if (fstate == 7){
8431 BrHXXRatio = (myNPbase->BrHZZRatio());
8432 dBrHXXRatio1 = BrHXXRatio - 1.0;
8433 dBrHXXRatio2 = 0.0;
8434 } else {
8435 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8436 }
8437
8438 //-- Production x Decay:
8439 if ((this->getModel()).isModelLinearized()){
8440 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8441 } else if((this->getModel()).isModelNPquadratic()){
8442 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8443 } else {
8444 return weight*(muProd)*(BrHXXRatio);
8445 }
8446
8447}
8448
8449
8450
8451
8452// -----------------------------------------------------------------------------
8453
8454
8455//VM:STXS2024;
8456STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8457: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8458{
8459 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8460 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8461
8462}
8463
8465{
8466 //-- Production:
8467 double weight = 1.0; //If normalized to the SM
8468 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8469 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8470 double muProd1 = muProd -1.0;
8471 double muProd2 = 0.0;
8472
8473 //-- Decay:
8474 double BrHXXRatio = 1.0;
8475 double dBrHXXRatio1 = 0.0;
8476 double dBrHXXRatio2 = 0.0;
8477 if (fstate==0){
8478 // Use for Cross-section [pb] with no Higgs-boson decay
8479 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8480 } else if (fstate == 1){
8481 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8482 dBrHXXRatio1 = BrHXXRatio - 1.0;
8483 dBrHXXRatio2 = 0.0;
8484 } else if (fstate == 2){
8485 BrHXXRatio = (myNPbase->BrHgagaRatio());
8486 dBrHXXRatio1 = BrHXXRatio - 1.0;
8487 dBrHXXRatio2 = 0.0;
8488 } else if (fstate == 3){
8489 BrHXXRatio = (myNPbase->BrHbbRatio());
8490 dBrHXXRatio1 = BrHXXRatio - 1.0;
8491 dBrHXXRatio2 = 0.0;
8492 } else if (fstate == 4){
8493 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8494 dBrHXXRatio1 = BrHXXRatio - 1.0;
8495 dBrHXXRatio2 = 0.0;
8496 } else if (fstate == 5){
8497 BrHXXRatio = (myNPbase->BrHtautauRatio());
8498 dBrHXXRatio1 = BrHXXRatio - 1.0;
8499 dBrHXXRatio2 = 0.0;
8500 } else if (fstate == 6){
8501 BrHXXRatio = (myNPbase->BrHWWRatio());
8502 dBrHXXRatio1 = BrHXXRatio - 1.0;
8503 dBrHXXRatio2 = 0.0;
8504 } else if (fstate == 7){
8505 BrHXXRatio = (myNPbase->BrHZZRatio());
8506 dBrHXXRatio1 = BrHXXRatio - 1.0;
8507 dBrHXXRatio2 = 0.0;
8508 } else {
8509 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8510 }
8511
8512 //-- Production x Decay:
8513 if ((this->getModel()).isModelLinearized()){
8514 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8515 } else if((this->getModel()).isModelNPquadratic()){
8516 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8517 } else {
8518 return weight*(muProd)*(BrHXXRatio);
8519 }
8520
8521}
8522
8523
8524
8525// -----------------------------------------------------------------------------
8526
8527
8528//VM:STXS2024;
8529STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8530: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8531{
8532 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8533 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8534
8535}
8536
8538{
8539 //-- Production:
8540 double weight = 1.0; //If normalized to the SM
8541 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8542 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8543 double muProd1 = muProd -1.0;
8544 double muProd2 = 0.0;
8545
8546 //-- Decay:
8547 double BrHXXRatio = 1.0;
8548 double dBrHXXRatio1 = 0.0;
8549 double dBrHXXRatio2 = 0.0;
8550 if (fstate==0){
8551 // Use for Cross-section [pb] with no Higgs-boson decay
8552 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8553 } else if (fstate == 1){
8554 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8555 dBrHXXRatio1 = BrHXXRatio - 1.0;
8556 dBrHXXRatio2 = 0.0;
8557 } else if (fstate == 2){
8558 BrHXXRatio = (myNPbase->BrHgagaRatio());
8559 dBrHXXRatio1 = BrHXXRatio - 1.0;
8560 dBrHXXRatio2 = 0.0;
8561 } else if (fstate == 3){
8562 BrHXXRatio = (myNPbase->BrHbbRatio());
8563 dBrHXXRatio1 = BrHXXRatio - 1.0;
8564 dBrHXXRatio2 = 0.0;
8565 } else if (fstate == 4){
8566 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8567 dBrHXXRatio1 = BrHXXRatio - 1.0;
8568 dBrHXXRatio2 = 0.0;
8569 } else if (fstate == 5){
8570 BrHXXRatio = (myNPbase->BrHtautauRatio());
8571 dBrHXXRatio1 = BrHXXRatio - 1.0;
8572 dBrHXXRatio2 = 0.0;
8573 } else if (fstate == 6){
8574 BrHXXRatio = (myNPbase->BrHWWRatio());
8575 dBrHXXRatio1 = BrHXXRatio - 1.0;
8576 dBrHXXRatio2 = 0.0;
8577 } else if (fstate == 7){
8578 BrHXXRatio = (myNPbase->BrHZZRatio());
8579 dBrHXXRatio1 = BrHXXRatio - 1.0;
8580 dBrHXXRatio2 = 0.0;
8581 } else {
8582 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8583 }
8584
8585 //-- Production x Decay:
8586 if ((this->getModel()).isModelLinearized()){
8587 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8588 } else if((this->getModel()).isModelNPquadratic()){
8589 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8590 } else {
8591 return weight*(muProd)*(BrHXXRatio);
8592 }
8593
8594}
8595
8596
8597
8598// -----------------------------------------------------------------------------
8599
8600
8601//VM:STXS2024;
8602STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8603: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8604{
8605 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8606 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8607
8608}
8609
8611{
8612 //-- Production:
8613 double weight = 1.0; //If normalized to the SM
8614 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8615 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8616 double muProd1 = muProd -1.0;
8617 double muProd2 = 0.0;
8618
8619 //-- Decay:
8620 double BrHXXRatio = 1.0;
8621 double dBrHXXRatio1 = 0.0;
8622 double dBrHXXRatio2 = 0.0;
8623 if (fstate==0){
8624 // Use for Cross-section [pb] with no Higgs-boson decay
8625 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8626 } else if (fstate == 1){
8627 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8628 dBrHXXRatio1 = BrHXXRatio - 1.0;
8629 dBrHXXRatio2 = 0.0;
8630 } else if (fstate == 2){
8631 BrHXXRatio = (myNPbase->BrHgagaRatio());
8632 dBrHXXRatio1 = BrHXXRatio - 1.0;
8633 dBrHXXRatio2 = 0.0;
8634 } else if (fstate == 3){
8635 BrHXXRatio = (myNPbase->BrHbbRatio());
8636 dBrHXXRatio1 = BrHXXRatio - 1.0;
8637 dBrHXXRatio2 = 0.0;
8638 } else if (fstate == 4){
8639 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8640 dBrHXXRatio1 = BrHXXRatio - 1.0;
8641 dBrHXXRatio2 = 0.0;
8642 } else if (fstate == 5){
8643 BrHXXRatio = (myNPbase->BrHtautauRatio());
8644 dBrHXXRatio1 = BrHXXRatio - 1.0;
8645 dBrHXXRatio2 = 0.0;
8646 } else if (fstate == 6){
8647 BrHXXRatio = (myNPbase->BrHWWRatio());
8648 dBrHXXRatio1 = BrHXXRatio - 1.0;
8649 dBrHXXRatio2 = 0.0;
8650 } else if (fstate == 7){
8651 BrHXXRatio = (myNPbase->BrHZZRatio());
8652 dBrHXXRatio1 = BrHXXRatio - 1.0;
8653 dBrHXXRatio2 = 0.0;
8654 } else {
8655 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8656 }
8657
8658 //-- Production x Decay:
8659 if ((this->getModel()).isModelLinearized()){
8660 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8661 } else if((this->getModel()).isModelNPquadratic()){
8662 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8663 } else {
8664 return weight*(muProd)*(BrHXXRatio);
8665 }
8666
8667}
8668
8669
8670// -----------------------------------------------------------------------------
8671
8672STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8673: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8674{
8675 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8676 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8677
8678}
8679
8681{
8682 double BrHXXRatio = 1.0;
8683 if (fstate == 1){
8684 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8685 } else if (fstate == 2){
8686 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8687 } else if (fstate == 3){
8688 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8689 } else if (fstate == 4){
8690 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8691 } else {
8692 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8693 }
8694
8695 if ((this->getModel()).isModelLinearized()) {
8696 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8697 } else {
8698 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8699 }
8700}
8701
8702// -----------------------------------------------------------------------------
8703
8704STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8705: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8706{
8707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8708 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8709
8710}
8711
8713{
8714 double BrHXXRatio = 1.0;
8715 if (fstate == 1){
8716 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8717 } else if (fstate == 2){
8718 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8719 } else if (fstate == 3){
8720 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8721 } else if (fstate == 4){
8722 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8723 } else {
8724 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8725 }
8726
8727 if ((this->getModel()).isModelLinearized()) {
8728 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8729 } else {
8730 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8731 }
8732}
8733
8734// -----------------------------------------------------------------------------
8735
8736STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8737: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8738{
8739 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8740 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8741
8742}
8743
8745{
8746 double BrHXXRatio = 1.0;
8747 if (fstate == 1){
8748 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8749 } else if (fstate == 2){
8750 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8751 } else if (fstate == 3){
8752 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8753 } else if (fstate == 4){
8754 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8755 } else {
8756 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8757 }
8758
8759 if ((this->getModel()).isModelLinearized()) {
8760 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8761 } else {
8762 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8763 }
8764}
8765
8766// -----------------------------------------------------------------------------
8767
8768STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8769: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8770{
8771 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8772 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8773
8774}
8775
8777{
8778 double BrHXXRatio = 1.0;
8779 if (fstate == 1){
8780 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8781 } else if (fstate == 2){
8782 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8783 } else if (fstate == 3){
8784 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8785 } else if (fstate == 4){
8786 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8787 } else {
8788 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8789 }
8790
8791 if ((this->getModel()).isModelLinearized()) {
8792 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8793 } else {
8794 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8795 }
8796}
8797
8798// -----------------------------------------------------------------------------
8799
8800STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8801: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8802{
8803 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8804 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8805
8806}
8807
8809{
8810 double BrHXXRatio = 1.0;
8811 if (fstate == 1){
8812 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8813 } else if (fstate == 2){
8814 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8815 } else if (fstate == 3){
8816 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8817 } else if (fstate == 4){
8818 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8819 } else {
8820 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8821 }
8822
8823 if ((this->getModel()).isModelLinearized()) {
8824 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8825 } else {
8826 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8827 }
8828}
8829
8830// -----------------------------------------------------------------------------
8831
8832STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8833: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8834{
8835 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8836 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8837
8838}
8839
8841{
8842 double BrHXXRatio = 1.0;
8843 if (fstate == 1){
8844 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8845 } else if (fstate == 2){
8846 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8847 } else if (fstate == 3){
8848 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8849 } else if (fstate == 4){
8850 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8851 } else {
8852 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8853 }
8854
8855 if ((this->getModel()).isModelLinearized()) {
8856 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8857 } else {
8858 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8859 }
8860}
8861
8862// -----------------------------------------------------------------------------
8863
8864STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8865: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8866{
8867 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8868 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8869
8870}
8871
8873{
8874 double BrHXXRatio = 1.0;
8875 if (fstate == 1){
8876 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8877 } else if (fstate == 2){
8878 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8879 } else if (fstate == 3){
8880 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8881 } else if (fstate == 4){
8882 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8883 } else {
8884 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8885 }
8886
8887 if ((this->getModel()).isModelLinearized()) {
8888 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8889 } else {
8890 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8891 }
8892}
8893
8894// -----------------------------------------------------------------------------
8895
8896STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8897: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8898{
8899 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8900 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8901
8902}
8903
8905{
8906 double BrHXXRatio = 1.0;
8907 if (fstate == 1){
8908 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8909 } else if (fstate == 2){
8910 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8911 } else if (fstate == 3){
8912 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8913 } else if (fstate == 4){
8914 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8915 } else {
8916 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8917 }
8918
8919 if ((this->getModel()).isModelLinearized()) {
8920 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8921 } else {
8922 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
8923 }
8924}
8925
8926
8927
8928// -----------------------------------------------------------------------------
8929
8930
8931//VM:STXS2024;
8932STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8933: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8934{
8935 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8936 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
8937
8938}
8939
8941{
8942 //-- Production:
8943 double weight = 1.0; //If normalized to the SM
8944 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8945 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
8946 double muProd1 = muProd -1.0;
8947 double muProd2 = 0.0;
8948
8949 //-- Decay:
8950 double BrHXXRatio = 1.0;
8951 double dBrHXXRatio1 = 0.0;
8952 double dBrHXXRatio2 = 0.0;
8953 if (fstate==0){
8954 // Use for Cross-section [pb] with no Higgs-boson decay
8955 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8956 } else if (fstate == 1){
8957 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8958 dBrHXXRatio1 = BrHXXRatio - 1.0;
8959 dBrHXXRatio2 = 0.0;
8960 } else if (fstate == 2){
8961 BrHXXRatio = (myNPbase->BrHgagaRatio());
8962 dBrHXXRatio1 = BrHXXRatio - 1.0;
8963 dBrHXXRatio2 = 0.0;
8964 } else if (fstate == 3){
8965 BrHXXRatio = (myNPbase->BrHbbRatio());
8966 dBrHXXRatio1 = BrHXXRatio - 1.0;
8967 dBrHXXRatio2 = 0.0;
8968 } else if (fstate == 4){
8969 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8970 dBrHXXRatio1 = BrHXXRatio - 1.0;
8971 dBrHXXRatio2 = 0.0;
8972 } else if (fstate == 5){
8973 BrHXXRatio = (myNPbase->BrHtautauRatio());
8974 dBrHXXRatio1 = BrHXXRatio - 1.0;
8975 dBrHXXRatio2 = 0.0;
8976 } else if (fstate == 6){
8977 BrHXXRatio = (myNPbase->BrHWWRatio());
8978 dBrHXXRatio1 = BrHXXRatio - 1.0;
8979 dBrHXXRatio2 = 0.0;
8980 } else if (fstate == 7){
8981 BrHXXRatio = (myNPbase->BrHZZRatio());
8982 dBrHXXRatio1 = BrHXXRatio - 1.0;
8983 dBrHXXRatio2 = 0.0;
8984 } else {
8985 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8986 }
8987
8988 //-- Production x Decay:
8989 if ((this->getModel()).isModelLinearized()){
8990 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8991 } else if((this->getModel()).isModelNPquadratic()){
8992 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8993 } else {
8994 return weight*(muProd)*(BrHXXRatio);
8995 }
8996
8997}
8998
8999
9000
9001
9002// -----------------------------------------------------------------------------
9003
9004
9005//VM:STXS2024;
9006STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9007: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9008{
9009 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9010 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9011
9012}
9013
9015{
9016 //-- Production:
9017 double weight = 1.0; //If normalized to the SM
9018 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9019 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9020 double muProd1 = muProd -1.0;
9021 double muProd2 = 0.0;
9022
9023 //-- Decay:
9024 double BrHXXRatio = 1.0;
9025 double dBrHXXRatio1 = 0.0;
9026 double dBrHXXRatio2 = 0.0;
9027 if (fstate==0){
9028 // Use for Cross-section [pb] with no Higgs-boson decay
9029 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9030 } else if (fstate == 1){
9031 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9032 dBrHXXRatio1 = BrHXXRatio - 1.0;
9033 dBrHXXRatio2 = 0.0;
9034 } else if (fstate == 2){
9035 BrHXXRatio = (myNPbase->BrHgagaRatio());
9036 dBrHXXRatio1 = BrHXXRatio - 1.0;
9037 dBrHXXRatio2 = 0.0;
9038 } else if (fstate == 3){
9039 BrHXXRatio = (myNPbase->BrHbbRatio());
9040 dBrHXXRatio1 = BrHXXRatio - 1.0;
9041 dBrHXXRatio2 = 0.0;
9042 } else if (fstate == 4){
9043 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9044 dBrHXXRatio1 = BrHXXRatio - 1.0;
9045 dBrHXXRatio2 = 0.0;
9046 } else if (fstate == 5){
9047 BrHXXRatio = (myNPbase->BrHtautauRatio());
9048 dBrHXXRatio1 = BrHXXRatio - 1.0;
9049 dBrHXXRatio2 = 0.0;
9050 } else if (fstate == 6){
9051 BrHXXRatio = (myNPbase->BrHWWRatio());
9052 dBrHXXRatio1 = BrHXXRatio - 1.0;
9053 dBrHXXRatio2 = 0.0;
9054 } else if (fstate == 7){
9055 BrHXXRatio = (myNPbase->BrHZZRatio());
9056 dBrHXXRatio1 = BrHXXRatio - 1.0;
9057 dBrHXXRatio2 = 0.0;
9058 } else {
9059 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9060 }
9061
9062 //-- Production x Decay:
9063 if ((this->getModel()).isModelLinearized()){
9064 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9065 } else if((this->getModel()).isModelNPquadratic()){
9066 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9067 } else {
9068 return weight*(muProd)*(BrHXXRatio);
9069 }
9070
9071}
9072
9073
9074
9075// -----------------------------------------------------------------------------
9076
9077//AG:STXS2024
9078STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9079: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9080{
9081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9082 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9083
9084}
9085
9087{
9088 //-- Production:
9089 double weight = 1.0; //If normalized to the SM
9090 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9091 double muProd1 = muProd -1.0;
9092 double muProd2 = 0.0;
9093
9094 //-- Decay:
9095 double BrHXXRatio = 1.0;
9096 double dBrHXXRatio1 = 0.0;
9097 double dBrHXXRatio2 = 0.0;
9098 if (fstate==0){
9099 // Use for Cross-section [pb] with no Higgs-boson decay
9100 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9101 } else if (fstate == 1){
9102 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9103 dBrHXXRatio1 = BrHXXRatio - 1.0;
9104 dBrHXXRatio2 = 0.0;
9105 } else if (fstate == 2){
9106 BrHXXRatio = (myNPbase->BrHgagaRatio());
9107 dBrHXXRatio1 = BrHXXRatio - 1.0;
9108 dBrHXXRatio2 = 0.0;
9109 } else if (fstate == 3){
9110 BrHXXRatio = (myNPbase->BrHbbRatio());
9111 dBrHXXRatio1 = BrHXXRatio - 1.0;
9112 dBrHXXRatio2 = 0.0;
9113 } else if (fstate == 4){
9114 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9115 dBrHXXRatio1 = BrHXXRatio - 1.0;
9116 dBrHXXRatio2 = 0.0;
9117 } else if (fstate == 5){
9118 BrHXXRatio = (myNPbase->BrHtautauRatio());
9119 dBrHXXRatio1 = BrHXXRatio - 1.0;
9120 dBrHXXRatio2 = 0.0;
9121 } else if (fstate == 6){
9122 BrHXXRatio = (myNPbase->BrHWWRatio());
9123 dBrHXXRatio1 = BrHXXRatio - 1.0;
9124 dBrHXXRatio2 = 0.0;
9125 } else if (fstate == 7){
9126 BrHXXRatio = (myNPbase->BrHZZRatio());
9127 dBrHXXRatio1 = BrHXXRatio - 1.0;
9128 dBrHXXRatio2 = 0.0;
9129 } else {
9130 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9131 }
9132
9133 //-- Production x Decay:
9134 if ((this->getModel()).isModelLinearized()){
9135 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9136 } else if((this->getModel()).isModelNPquadratic()){
9137 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9138 } else {
9139 return weight*(muProd)*(BrHXXRatio);
9140 }
9141}
9142
9143// -----------------------------------------------------------------------------
9144
9145STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9146: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9147{
9148 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9149 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9150
9151}
9152
9154{
9155 double BrHXXRatio = 1.0;
9156 if (fstate == 1){
9157 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9158 } else if (fstate == 2){
9159 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9160 } else if (fstate == 3){
9161 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9162 } else if (fstate == 4){
9163 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9164 } else {
9165 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9166 }
9167
9168 if ((this->getModel()).isModelLinearized()) {
9169 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9170 } else {
9171 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9172 }
9173}
9174
9175// -----------------------------------------------------------------------------
9176
9177//AG:STXS2024
9179: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9180{
9181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9182 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9183
9184}
9185
9187{
9188 //-- Production:
9189 double weight = 1.0; //If normalized to the SM
9191 double muProd1 = muProd -1.0;
9192 double muProd2 = 0.0;
9193
9194 //-- Decay:
9195 double BrHXXRatio = 1.0;
9196 double dBrHXXRatio1 = 0.0;
9197 double dBrHXXRatio2 = 0.0;
9198 if (fstate==0){
9199 // Use for Cross-section [pb] with no Higgs-boson decay
9200 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9201 } else if (fstate == 1){
9202 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9203 dBrHXXRatio1 = BrHXXRatio - 1.0;
9204 dBrHXXRatio2 = 0.0;
9205 } else if (fstate == 2){
9206 BrHXXRatio = (myNPbase->BrHgagaRatio());
9207 dBrHXXRatio1 = BrHXXRatio - 1.0;
9208 dBrHXXRatio2 = 0.0;
9209 } else if (fstate == 3){
9210 BrHXXRatio = (myNPbase->BrHbbRatio());
9211 dBrHXXRatio1 = BrHXXRatio - 1.0;
9212 dBrHXXRatio2 = 0.0;
9213 } else if (fstate == 4){
9214 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9215 dBrHXXRatio1 = BrHXXRatio - 1.0;
9216 dBrHXXRatio2 = 0.0;
9217 } else if (fstate == 5){
9218 BrHXXRatio = (myNPbase->BrHtautauRatio());
9219 dBrHXXRatio1 = BrHXXRatio - 1.0;
9220 dBrHXXRatio2 = 0.0;
9221 } else if (fstate == 6){
9222 BrHXXRatio = (myNPbase->BrHWWRatio());
9223 dBrHXXRatio1 = BrHXXRatio - 1.0;
9224 dBrHXXRatio2 = 0.0;
9225 } else if (fstate == 7){
9226 BrHXXRatio = (myNPbase->BrHZZRatio());
9227 dBrHXXRatio1 = BrHXXRatio - 1.0;
9228 dBrHXXRatio2 = 0.0;
9229 } else {
9230 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9231 }
9232
9233
9234 //-- Production x Decay:
9235 if ((this->getModel()).isModelLinearized()){
9236 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9237 } else if((this->getModel()).isModelNPquadratic()){
9238 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9239 } else {
9240 return weight*(muProd)*(BrHXXRatio);
9241 }
9242
9243}
9244
9245// -----------------------------------------------------------------------------
9246
9248: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9249{
9250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9251 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9252
9253}
9254
9256{
9257 double BrHXXRatio = 1.0;
9258 if (fstate == 1){
9259 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9260 } else if (fstate == 2){
9261 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9262 } else if (fstate == 3){
9263 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9264 } else if (fstate == 4){
9265 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9266 } else {
9267 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9268 }
9269
9270 if ((this->getModel()).isModelLinearized()) {
9271 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9272 } else {
9274 }
9275}
9276
9277// -----------------------------------------------------------------------------
9278
9280: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9281{
9282 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9283 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9284
9285}
9286
9288{
9289 double BrHXXRatio = 1.0;
9290 if (fstate == 1){
9291 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9292 } else if (fstate == 2){
9293 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9294 } else if (fstate == 3){
9295 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9296 } else if (fstate == 4){
9297 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9298 } else {
9299 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9300 }
9301
9302 if ((this->getModel()).isModelLinearized()) {
9303 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9304 } else {
9306 }
9307}
9308
9309// -----------------------------------------------------------------------------
9310
9312: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9313{
9314 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9315 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9316
9317}
9318
9320{
9321 double BrHXXRatio = 1.0;
9322 if (fstate == 1){
9323 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9324 } else if (fstate == 2){
9325 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9326 } else if (fstate == 3){
9327 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9328 } else if (fstate == 4){
9329 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9330 } else {
9331 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9332 }
9333
9334 if ((this->getModel()).isModelLinearized()) {
9335 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9336 } else {
9338 }
9339}
9340
9341// -----------------------------------------------------------------------------
9342
9344: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9345{
9346 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9347 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9348
9349}
9350
9352{
9353 double BrHXXRatio = 1.0;
9354 if (fstate == 1){
9355 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9356 } else if (fstate == 2){
9357 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9358 } else if (fstate == 3){
9359 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9360 } else if (fstate == 4){
9361 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9362 } else {
9363 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9364 }
9365
9366 if ((this->getModel()).isModelLinearized()) {
9367 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9368 } else {
9370 }
9371}
9372
9373// -----------------------------------------------------------------------------
9374
9375//AG:STXS2024
9376STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9377: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9378{
9379 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9380 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9381
9382}
9383
9385{
9386 //-- Production:
9387 double weight = 1.0; //If normalized to the SM
9389 double muProd1 = muProd -1.0;
9390 double muProd2 = 0.0;
9391
9392 //-- Decay:
9393 double BrHXXRatio = 1.0;
9394 double dBrHXXRatio1 = 0.0;
9395 double dBrHXXRatio2 = 0.0;
9396 if (fstate==0){
9397 // Use for Cross-section [pb] with no Higgs-boson decay
9398 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9399 } else if (fstate == 1){
9400 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9401 dBrHXXRatio1 = BrHXXRatio - 1.0;
9402 dBrHXXRatio2 = 0.0;
9403 } else if (fstate == 2){
9404 BrHXXRatio = (myNPbase->BrHgagaRatio());
9405 dBrHXXRatio1 = BrHXXRatio - 1.0;
9406 dBrHXXRatio2 = 0.0;
9407 } else if (fstate == 3){
9408 BrHXXRatio = (myNPbase->BrHbbRatio());
9409 dBrHXXRatio1 = BrHXXRatio - 1.0;
9410 dBrHXXRatio2 = 0.0;
9411 } else if (fstate == 4){
9412 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9413 dBrHXXRatio1 = BrHXXRatio - 1.0;
9414 dBrHXXRatio2 = 0.0;
9415 } else if (fstate == 5){
9416 BrHXXRatio = (myNPbase->BrHtautauRatio());
9417 dBrHXXRatio1 = BrHXXRatio - 1.0;
9418 dBrHXXRatio2 = 0.0;
9419 } else if (fstate == 6){
9420 BrHXXRatio = (myNPbase->BrHWWRatio());
9421 dBrHXXRatio1 = BrHXXRatio - 1.0;
9422 dBrHXXRatio2 = 0.0;
9423 } else {
9424 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9425 }
9426
9427 //-- Production x Decay:
9428 if ((this->getModel()).isModelLinearized()){
9429 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9430 } else if((this->getModel()).isModelNPquadratic()){
9431 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9432 } else {
9433 return weight*(muProd)*(BrHXXRatio);
9434 }
9435
9436
9437}
9438
9439// -----------------------------------------------------------------------------
9440
9441//AG:STXS2024
9442STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9443: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9444{
9445 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9446 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9447
9448}
9449
9451{
9452 //-- Production:
9453 double weight = 1.0; //If normalized to the SM
9455 double muProd1 = muProd -1.0;
9456 double muProd2 = 0.0;
9457
9458 //-- Decay:
9459 double BrHXXRatio = 1.0;
9460 double dBrHXXRatio1 = 0.0;
9461 double dBrHXXRatio2 = 0.0;
9462 if (fstate==0){
9463 // Use for Cross-section [pb] with no Higgs-boson decay
9464 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9465 } else if (fstate == 1){
9466 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9467 dBrHXXRatio1 = BrHXXRatio - 1.0;
9468 dBrHXXRatio2 = 0.0;
9469 } else if (fstate == 2){
9470 BrHXXRatio = (myNPbase->BrHgagaRatio());
9471 dBrHXXRatio1 = BrHXXRatio - 1.0;
9472 dBrHXXRatio2 = 0.0;
9473 } else if (fstate == 3){
9474 BrHXXRatio = (myNPbase->BrHbbRatio());
9475 dBrHXXRatio1 = BrHXXRatio - 1.0;
9476 dBrHXXRatio2 = 0.0;
9477 } else if (fstate == 4){
9478 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9479 dBrHXXRatio1 = BrHXXRatio - 1.0;
9480 dBrHXXRatio2 = 0.0;
9481 } else if (fstate == 5){
9482 BrHXXRatio = (myNPbase->BrHtautauRatio());
9483 dBrHXXRatio1 = BrHXXRatio - 1.0;
9484 dBrHXXRatio2 = 0.0;
9485 } else if (fstate == 6){
9486 BrHXXRatio = (myNPbase->BrHWWRatio());
9487 dBrHXXRatio1 = BrHXXRatio - 1.0;
9488 dBrHXXRatio2 = 0.0;
9489 } else {
9490 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9491 }
9492
9493 //-- Production x Decay:
9494 if ((this->getModel()).isModelLinearized()){
9495 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9496 } else if((this->getModel()).isModelNPquadratic()){
9497 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9498 } else {
9499 return weight*(muProd)*(BrHXXRatio);
9500 }
9501
9502
9503}
9504
9505// -----------------------------------------------------------------------------
9506
9507//AG:STXS2024
9508STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9509: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9510{
9511 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9512 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9513
9514}
9515
9517{
9518 //-- Production:
9519 double weight = 1.0; //If normalized to the SM
9521 double muProd1 = muProd -1.0;
9522 double muProd2 = 0.0;
9523
9524 //-- Decay:
9525 double BrHXXRatio = 1.0;
9526 double dBrHXXRatio1 = 0.0;
9527 double dBrHXXRatio2 = 0.0;
9528 if (fstate==0){
9529 // Use for Cross-section [pb] with no Higgs-boson decay
9530 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9531 } else if (fstate == 1){
9532 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9533 dBrHXXRatio1 = BrHXXRatio - 1.0;
9534 dBrHXXRatio2 = 0.0;
9535 } else if (fstate == 2){
9536 BrHXXRatio = (myNPbase->BrHgagaRatio());
9537 dBrHXXRatio1 = BrHXXRatio - 1.0;
9538 dBrHXXRatio2 = 0.0;
9539 } else if (fstate == 3){
9540 BrHXXRatio = (myNPbase->BrHbbRatio());
9541 dBrHXXRatio1 = BrHXXRatio - 1.0;
9542 dBrHXXRatio2 = 0.0;
9543 } else if (fstate == 4){
9544 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9545 dBrHXXRatio1 = BrHXXRatio - 1.0;
9546 dBrHXXRatio2 = 0.0;
9547 } else if (fstate == 5){
9548 BrHXXRatio = (myNPbase->BrHtautauRatio());
9549 dBrHXXRatio1 = BrHXXRatio - 1.0;
9550 dBrHXXRatio2 = 0.0;
9551 } else if (fstate == 6){
9552 BrHXXRatio = (myNPbase->BrHWWRatio());
9553 dBrHXXRatio1 = BrHXXRatio - 1.0;
9554 dBrHXXRatio2 = 0.0;
9555 } else {
9556 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9557 }
9558
9559 //-- Production x Decay:
9560 if ((this->getModel()).isModelLinearized()){
9561 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9562 } else if((this->getModel()).isModelNPquadratic()){
9563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9564 } else {
9565 return weight*(muProd)*(BrHXXRatio);
9566 }
9567
9568
9569}
9570
9571// -----------------------------------------------------------------------------
9572
9573//AG:STXS2024
9574STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9575: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9576{
9577 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9578 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9579
9580}
9581
9583{
9584 //-- Production:
9585 double weight = 1.0; //If normalized to the SM
9587 double muProd1 = muProd -1.0;
9588 double muProd2 = 0.0;
9589
9590 //-- Decay:
9591 double BrHXXRatio = 1.0;
9592 double dBrHXXRatio1 = 0.0;
9593 double dBrHXXRatio2 = 0.0;
9594 if (fstate==0){
9595 // Use for Cross-section [pb] with no Higgs-boson decay
9596 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9597 } else if (fstate == 1){
9598 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9599 dBrHXXRatio1 = BrHXXRatio - 1.0;
9600 dBrHXXRatio2 = 0.0;
9601 } else if (fstate == 2){
9602 BrHXXRatio = (myNPbase->BrHgagaRatio());
9603 dBrHXXRatio1 = BrHXXRatio - 1.0;
9604 dBrHXXRatio2 = 0.0;
9605 } else if (fstate == 3){
9606 BrHXXRatio = (myNPbase->BrHbbRatio());
9607 dBrHXXRatio1 = BrHXXRatio - 1.0;
9608 dBrHXXRatio2 = 0.0;
9609 } else if (fstate == 4){
9610 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9611 dBrHXXRatio1 = BrHXXRatio - 1.0;
9612 dBrHXXRatio2 = 0.0;
9613 } else if (fstate == 5){
9614 BrHXXRatio = (myNPbase->BrHtautauRatio());
9615 dBrHXXRatio1 = BrHXXRatio - 1.0;
9616 dBrHXXRatio2 = 0.0;
9617 } else if (fstate == 6){
9618 BrHXXRatio = (myNPbase->BrHWWRatio());
9619 dBrHXXRatio1 = BrHXXRatio - 1.0;
9620 dBrHXXRatio2 = 0.0;
9621 } else {
9622 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9623 }
9624
9625 //-- Production x Decay:
9626 if ((this->getModel()).isModelLinearized()){
9627 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9628 } else if((this->getModel()).isModelNPquadratic()){
9629 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9630 } else {
9631 return weight*(muProd)*(BrHXXRatio);
9632 }
9633
9634}
9635
9636// -----------------------------------------------------------------------------
9637
9638//AG:STXS2024
9639STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9640: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9641{
9642 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9643 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9644
9645}
9646
9648{
9649 //-- Production:
9650 double weight = 1.0; //If normalized to the SM
9651 //Since adding bins, include partial weigths of SM_predictions
9652 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9653 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9654 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9655 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9656 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9657 double muProd2 = 0.0;
9658
9659 //-- Decay:
9660 double BrHXXRatio = 1.0;
9661 double dBrHXXRatio1 = 0.0;
9662 double dBrHXXRatio2 = 0.0;
9663 if (fstate==0){
9664 // Use for Cross-section [pb] with no Higgs-boson decay
9665 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9666 } else if (fstate == 1){
9667 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9668 dBrHXXRatio1 = BrHXXRatio - 1.0;
9669 dBrHXXRatio2 = 0.0;
9670 } else if (fstate == 2){
9671 BrHXXRatio = (myNPbase->BrHgagaRatio());
9672 dBrHXXRatio1 = BrHXXRatio - 1.0;
9673 dBrHXXRatio2 = 0.0;
9674 } else if (fstate == 3){
9675 BrHXXRatio = (myNPbase->BrHbbRatio());
9676 dBrHXXRatio1 = BrHXXRatio - 1.0;
9677 dBrHXXRatio2 = 0.0;
9678 } else if (fstate == 4){
9679 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9680 dBrHXXRatio1 = BrHXXRatio - 1.0;
9681 dBrHXXRatio2 = 0.0;
9682 } else {
9683 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9684 }
9685
9686 //-- Production x Decay:
9687 if ((this->getModel()).isModelLinearized()){
9688 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9689 } else if((this->getModel()).isModelNPquadratic()){
9690 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9691 } else {
9692 return weight*(muProd)*(BrHXXRatio);
9693 }
9694
9695
9696}
9697
9698// -----------------------------------------------------------------------------
9699
9700//AG:STXS2024
9701STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9702: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9703{
9704 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9705 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9706
9707}
9708
9710{
9711 //-- Production:
9712 double weight = 1.0; //If normalized to the SM
9714 double muProd1 = muProd -1.0;
9715 double muProd2 = 0.0;
9716
9717 //-- Decay:
9718 double BrHXXRatio = 1.0;
9719 double dBrHXXRatio1 = 0.0;
9720 double dBrHXXRatio2 = 0.0;
9721 if (fstate==0){
9722 // Use for Cross-section [pb] with no Higgs-boson decay
9723 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9724 } else if (fstate == 1){
9725 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9726 dBrHXXRatio1 = BrHXXRatio - 1.0;
9727 dBrHXXRatio2 = 0.0;
9728 } else if (fstate == 2){
9729 BrHXXRatio = (myNPbase->BrHgagaRatio());
9730 dBrHXXRatio1 = BrHXXRatio - 1.0;
9731 dBrHXXRatio2 = 0.0;
9732 } else if (fstate == 3){
9733 BrHXXRatio = (myNPbase->BrHbbRatio());
9734 dBrHXXRatio1 = BrHXXRatio - 1.0;
9735 dBrHXXRatio2 = 0.0;
9736 } else if (fstate == 4){
9737 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9738 dBrHXXRatio1 = BrHXXRatio - 1.0;
9739 dBrHXXRatio2 = 0.0;
9740 } else {
9741 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9742 }
9743
9744 //-- Production x Decay:
9745 if ((this->getModel()).isModelLinearized()){
9746 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9747 } else if((this->getModel()).isModelNPquadratic()){
9748 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9749 } else {
9750 return weight*(muProd)*(BrHXXRatio);
9751 }
9752
9753
9754}
9755
9756// -----------------------------------------------------------------------------
9757
9758//AG:STXS2024
9759STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9760: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9761{
9762 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9763 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9764
9765}
9766
9768{
9769 //-- Production:
9770 double weight = 1.0; //If normalized to the SM
9772 double muProd1 = muProd -1.0;
9773 double muProd2 = 0.0;
9774
9775 //-- Decay:
9776 double BrHXXRatio = 1.0;
9777 double dBrHXXRatio1 = 0.0;
9778 double dBrHXXRatio2 = 0.0;
9779 if (fstate==0){
9780 // Use for Cross-section [pb] with no Higgs-boson decay
9781 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9782 } else if (fstate == 1){
9783 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9784 dBrHXXRatio1 = BrHXXRatio - 1.0;
9785 dBrHXXRatio2 = 0.0;
9786 } else if (fstate == 2){
9787 BrHXXRatio = (myNPbase->BrHgagaRatio());
9788 dBrHXXRatio1 = BrHXXRatio - 1.0;
9789 dBrHXXRatio2 = 0.0;
9790 } else if (fstate == 3){
9791 BrHXXRatio = (myNPbase->BrHbbRatio());
9792 dBrHXXRatio1 = BrHXXRatio - 1.0;
9793 dBrHXXRatio2 = 0.0;
9794 } else if (fstate == 4){
9795 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9796 dBrHXXRatio1 = BrHXXRatio - 1.0;
9797 dBrHXXRatio2 = 0.0;
9798 } else {
9799 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9800 }
9801
9802 //-- Production x Decay:
9803 if ((this->getModel()).isModelLinearized()){
9804 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9805 } else if((this->getModel()).isModelNPquadratic()){
9806 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9807 } else {
9808 return weight*(muProd)*(BrHXXRatio);
9809 }
9810
9811
9812}
9813
9814// -----------------------------------------------------------------------------
9815
9816STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9817: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9818{
9819 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9820 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9821
9822}
9823
9825{
9826 //-- Production:
9827 double weight = 1.0; //If normalized to the SM
9828 //Since adding bins, include partial weigths of SM_predictions
9829 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9830
9831 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9837 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9838
9839 double muProd1 = muProd - 1.;
9840 double muProd2 = 0.0;
9841
9842 //-- Decay:
9843 double BrHXXRatio = 1.0;
9844 double dBrHXXRatio1 = 0.0;
9845 double dBrHXXRatio2 = 0.0;
9846 if (fstate==0){
9847 // Use for Cross-section [pb] with no Higgs-boson decay
9848 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9849 } else if (fstate == 1){
9850 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9851 dBrHXXRatio1 = BrHXXRatio - 1.0;
9852 dBrHXXRatio2 = 0.0;
9853 } else if (fstate == 2){
9854 BrHXXRatio = (myNPbase->BrHgagaRatio());
9855 dBrHXXRatio1 = BrHXXRatio - 1.0;
9856 dBrHXXRatio2 = 0.0;
9857 } else if (fstate == 3){
9858 BrHXXRatio = (myNPbase->BrHbbRatio());
9859 dBrHXXRatio1 = BrHXXRatio - 1.0;
9860 dBrHXXRatio2 = 0.0;
9861 } else if (fstate == 4){
9862 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9863 dBrHXXRatio1 = BrHXXRatio - 1.0;
9864 dBrHXXRatio2 = 0.0;
9865 } else if (fstate == 5){
9866 BrHXXRatio = (myNPbase->BrHtautauRatio());
9867 dBrHXXRatio1 = BrHXXRatio - 1.0;
9868 dBrHXXRatio2 = 0.0;
9869 } else {
9870 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9871 }
9872
9873
9874
9875
9876 //-- Production x Decay:
9877 if ((this->getModel()).isModelLinearized()){
9878// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9879 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9880 } else if((this->getModel()).isModelNPquadratic()){
9881// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9882 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9883 } else {
9884// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9885 return weight*(muProd)*(BrHXXRatio);
9886 }
9887
9888}
9889
9890// -----------------------------------------------------------------------------
9891
9892STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9893: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9894{
9895 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9896 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9897
9898}
9899
9901{
9902 //-- Production:
9903 double weight = 1.0; //If normalized to the SM
9904 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9905 double muProd1 = muProd -1.0;
9906 double muProd2 = 0.0;
9907
9908 //-- Decay:
9909 double BrHXXRatio = 1.0;
9910 double dBrHXXRatio1 = 0.0;
9911 double dBrHXXRatio2 = 0.0;
9912 if (fstate==0){
9913 // Use for Cross-section [pb] with no Higgs-boson decay
9914 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9915 } else if (fstate == 1){
9916 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9917 dBrHXXRatio1 = BrHXXRatio - 1.0;
9918 dBrHXXRatio2 = 0.0;
9919 } else if (fstate == 2){
9920 BrHXXRatio = (myNPbase->BrHgagaRatio());
9921 dBrHXXRatio1 = BrHXXRatio - 1.0;
9922 dBrHXXRatio2 = 0.0;
9923 } else if (fstate == 3){
9924 BrHXXRatio = (myNPbase->BrHbbRatio());
9925 dBrHXXRatio1 = BrHXXRatio - 1.0;
9926 dBrHXXRatio2 = 0.0;
9927 } else if (fstate == 4){
9928 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9929 dBrHXXRatio1 = BrHXXRatio - 1.0;
9930 dBrHXXRatio2 = 0.0;
9931 } else if (fstate == 5){
9932 BrHXXRatio = (myNPbase->BrHtautauRatio());
9933 dBrHXXRatio1 = BrHXXRatio - 1.0;
9934 dBrHXXRatio2 = 0.0;
9935 } else {
9936 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9937 }
9938
9939 //-- Production x Decay:
9940 if ((this->getModel()).isModelLinearized()){
9941 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9942 } else if((this->getModel()).isModelNPquadratic()){
9943 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9944 } else {
9945 return weight*(muProd)*(BrHXXRatio);
9946 }
9947
9948}
9949
9950// -----------------------------------------------------------------------------
9951
9952STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9953: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9954{
9955 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9956 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
9957
9958}
9959
9961{
9962 //-- Production:
9963 double weight = 1.0; //If normalized to the SM
9964 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
9965 double muProd1 = muProd -1.0;
9966 double muProd2 = 0.0;
9967
9968 //-- Decay:
9969 double BrHXXRatio = 1.0;
9970 double dBrHXXRatio1 = 0.0;
9971 double dBrHXXRatio2 = 0.0;
9972 if (fstate==0){
9973 // Use for Cross-section [pb] with no Higgs-boson decay
9974 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9975 } else if (fstate == 1){
9976 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9977 dBrHXXRatio1 = BrHXXRatio - 1.0;
9978 dBrHXXRatio2 = 0.0;
9979 } else if (fstate == 2){
9980 BrHXXRatio = (myNPbase->BrHgagaRatio());
9981 dBrHXXRatio1 = BrHXXRatio - 1.0;
9982 dBrHXXRatio2 = 0.0;
9983 } else if (fstate == 3){
9984 BrHXXRatio = (myNPbase->BrHbbRatio());
9985 dBrHXXRatio1 = BrHXXRatio - 1.0;
9986 dBrHXXRatio2 = 0.0;
9987 } else if (fstate == 4){
9988 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9989 dBrHXXRatio1 = BrHXXRatio - 1.0;
9990 dBrHXXRatio2 = 0.0;
9991 } else if (fstate == 5){
9992 BrHXXRatio = (myNPbase->BrHtautauRatio());
9993 dBrHXXRatio1 = BrHXXRatio - 1.0;
9994 dBrHXXRatio2 = 0.0;
9995 } else {
9996 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
9997 }
9998
9999 //-- Production x Decay:
10000 if ((this->getModel()).isModelLinearized()){
10001 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10002 } else if((this->getModel()).isModelNPquadratic()){
10003 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10004 } else {
10005 return weight*(muProd)*(BrHXXRatio);
10006 }
10007
10008}
10009
10010// -----------------------------------------------------------------------------
10011
10012//AG:STXS2024
10013STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10014: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10015{
10016 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10017 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10018
10019}
10020
10022{
10023 //-- Production:
10024 double weight = 1.0; //If normalized to the SM
10026 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10027 double muProd2 = 0.0;
10028
10029 //-- Decay:
10030 double BrHXXRatio = 1.0;
10031 double dBrHXXRatio1 = 0.0;
10032 double dBrHXXRatio2 = 0.0;
10033 if (fstate==0){
10034 // Use for Cross-section [pb] with no Higgs-boson decay
10035 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10036 } else if (fstate == 1){
10037 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10038 dBrHXXRatio1 = BrHXXRatio - 1.0;
10039 dBrHXXRatio2 = 0.0;
10040 } else if (fstate == 2){
10041 BrHXXRatio = (myNPbase->BrHgagaRatio());
10042 dBrHXXRatio1 = BrHXXRatio - 1.0;
10043 dBrHXXRatio2 = 0.0;
10044 } else if (fstate == 3){
10045 BrHXXRatio = (myNPbase->BrHbbRatio());
10046 dBrHXXRatio1 = BrHXXRatio - 1.0;
10047 dBrHXXRatio2 = 0.0;
10048 } else if (fstate == 4){
10049 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10050 dBrHXXRatio1 = BrHXXRatio - 1.0;
10051 dBrHXXRatio2 = 0.0;
10052 } else if (fstate == 5){
10053 BrHXXRatio = (myNPbase->BrHtautauRatio());
10054 dBrHXXRatio1 = BrHXXRatio - 1.0;
10055 dBrHXXRatio2 = 0.0;
10056 } else {
10057 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10058 }
10059
10060 //-- Production x Decay:
10061 if ((this->getModel()).isModelLinearized()){
10062 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10063 } else if((this->getModel()).isModelNPquadratic()){
10064 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10065 } else {
10066 return weight*(muProd)*(BrHXXRatio);
10067 }
10068
10069
10070}
10071
10072// -----------------------------------------------------------------------------
10073
10074STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10075: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10076{
10077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10078 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10079
10080}
10081
10083{
10084 double BrHXXRatio = 1.0;
10085 if (fstate == 1){
10086 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10087 } else if (fstate == 2){
10088 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10089 } else if (fstate == 3){
10090 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10091 } else if (fstate == 4){
10092 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10093 } else {
10094 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10095 }
10096
10097 if ((this->getModel()).isModelLinearized()) {
10098 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10099 } else {
10100 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10101 }
10102}
10103
10104// -----------------------------------------------------------------------------
10105
10106STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10107: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10108{
10109 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10110 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10111
10112}
10113
10115{
10116 double BrHXXRatio = 1.0;
10117 if (fstate == 1){
10118 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10119 } else if (fstate == 2){
10120 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10121 } else if (fstate == 3){
10122 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10123 } else if (fstate == 4){
10124 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10125 } else {
10126 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10127 }
10128
10129 if ((this->getModel()).isModelLinearized()) {
10130 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10131 } else {
10132 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10133 }
10134}
10135
10136// -----------------------------------------------------------------------------
10137
10138//AG:STXS2024
10139STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10140: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10141{
10142 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10143 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10144
10145}
10146
10148{
10149 //-- Production:
10150 double weight = 1.0; //If normalized to the SM
10151 //Since adding bins, include partial weigths of SM_predictions
10152 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10153 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10154 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10155 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10156 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10157 double muProd2 = 0.0;
10158
10159 //-- Decay:
10160 double BrHXXRatio = 1.0;
10161 double dBrHXXRatio1 = 0.0;
10162 double dBrHXXRatio2 = 0.0;
10163 if (fstate==0){
10164 // Use for Cross-section [pb] with no Higgs-boson decay
10165 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10166 } else if (fstate == 1){
10167 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10168 dBrHXXRatio1 = BrHXXRatio - 1.0;
10169 dBrHXXRatio2 = 0.0;
10170 } else if (fstate == 2){
10171 BrHXXRatio = (myNPbase->BrHgagaRatio());
10172 dBrHXXRatio1 = BrHXXRatio - 1.0;
10173 dBrHXXRatio2 = 0.0;
10174 } else if (fstate == 3){
10175 BrHXXRatio = (myNPbase->BrHbbRatio());
10176 dBrHXXRatio1 = BrHXXRatio - 1.0;
10177 dBrHXXRatio2 = 0.0;
10178 } else if (fstate == 4){
10179 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10180 dBrHXXRatio1 = BrHXXRatio - 1.0;
10181 dBrHXXRatio2 = 0.0;
10182 } else {
10183 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10184 }
10185
10186 //-- Production x Decay:
10187 if ((this->getModel()).isModelLinearized()){
10188 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10189 } else if((this->getModel()).isModelNPquadratic()){
10190 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10191 } else {
10192 return weight*(muProd)*(BrHXXRatio);
10193 }
10194
10195
10196}
10197
10198// -----------------------------------------------------------------------------
10199
10200//AG:STXS2024
10201STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10202: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10203{
10204 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10205 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10206
10207}
10208
10210{
10211 //-- Production:
10212 double weight = 1.0; //If normalized to the SM
10213 //Since adding bins, include partial weigths of SM_predictions
10214 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10215 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10217 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10218 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10219 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10220 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10221 double muProd2 = 0.0;
10222
10223 //-- Decay:
10224 double BrHXXRatio = 1.0;
10225 double dBrHXXRatio1 = 0.0;
10226 double dBrHXXRatio2 = 0.0;
10227 if (fstate==0){
10228 // Use for Cross-section [pb] with no Higgs-boson decay
10229 weight = 1.0 ;
10230 } else if (fstate == 1){
10231 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10232 dBrHXXRatio1 = BrHXXRatio - 1.0;
10233 dBrHXXRatio2 = 0.0;
10234 } else if (fstate == 2){
10235 BrHXXRatio = (myNPbase->BrHgagaRatio());
10236 dBrHXXRatio1 = BrHXXRatio - 1.0;
10237 dBrHXXRatio2 = 0.0;
10238 } else if (fstate == 3){
10239 BrHXXRatio = (myNPbase->BrHbbRatio());
10240 dBrHXXRatio1 = BrHXXRatio - 1.0;
10241 dBrHXXRatio2 = 0.0;
10242 } else if (fstate == 4){
10243 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10244 dBrHXXRatio1 = BrHXXRatio - 1.0;
10245 dBrHXXRatio2 = 0.0;
10246 } else {
10247 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10248 }
10249
10250 //-- Production x Decay:
10251 if ((this->getModel()).isModelLinearized()){
10252 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10253 } else if((this->getModel()).isModelNPquadratic()){
10254 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10255 } else {
10256 return weight*(muProd)*(BrHXXRatio);
10257 }
10258
10259
10260}
10261
10262// -----------------------------------------------------------------------------
10263
10264//AG:STXS2024
10265STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10266: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10267{
10268 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10269 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10270
10271}
10272
10274{
10275 //-- Production:
10276 double weight = 1.0; //If normalized to the SM
10277 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10278 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10279 double muProd2 = 0.0;
10280
10281 //-- Decay:
10282 double BrHXXRatio = 1.0;
10283 double dBrHXXRatio1 = 0.0;
10284 double dBrHXXRatio2 = 0.0;
10285 if (fstate==0){
10286 // Use for Cross-section [pb] with no Higgs-boson decay
10287 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10288 } else if (fstate == 1){
10289 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10290 dBrHXXRatio1 = BrHXXRatio - 1.0;
10291 dBrHXXRatio2 = 0.0;
10292 } else if (fstate == 2){
10293 BrHXXRatio = (myNPbase->BrHgagaRatio());
10294 dBrHXXRatio1 = BrHXXRatio - 1.0;
10295 dBrHXXRatio2 = 0.0;
10296 } else if (fstate == 3){
10297 BrHXXRatio = (myNPbase->BrHbbRatio());
10298 dBrHXXRatio1 = BrHXXRatio - 1.0;
10299 dBrHXXRatio2 = 0.0;
10300 } else if (fstate == 4){
10301 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10302 dBrHXXRatio1 = BrHXXRatio - 1.0;
10303 dBrHXXRatio2 = 0.0;
10304 } else {
10305 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10306 }
10307
10308 //-- Production x Decay:
10309 if ((this->getModel()).isModelLinearized()){
10310 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10311 } else if((this->getModel()).isModelNPquadratic()){
10312 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10313 } else {
10314 return weight*(muProd)*(BrHXXRatio);
10315 }
10316
10317
10318}
10319
10320// -----------------------------------------------------------------------------
10321
10322//AG:STXS2024
10323STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10324: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10325{
10326 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10327 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10328
10329}
10330
10332{
10333 //-- Production:
10334 double weight = 1.0; //If normalized to the SM
10335 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10336 double muProd1 = muProd-1.0 ;
10337 double muProd2 = 0.0;
10338
10339 //-- Decay:
10340 double BrHXXRatio = 1.0;
10341 double dBrHXXRatio1 = 0.0;
10342 double dBrHXXRatio2 = 0.0;
10343 if (fstate==0){
10344 // Use for Cross-section [pb] with no Higgs-boson decay
10345 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10346 } else if (fstate == 1){
10347 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10348 dBrHXXRatio1 = BrHXXRatio - 1.0;
10349 dBrHXXRatio2 = 0.0;
10350 } else if (fstate == 2){
10351 BrHXXRatio = (myNPbase->BrHgagaRatio());
10352 dBrHXXRatio1 = BrHXXRatio - 1.0;
10353 dBrHXXRatio2 = 0.0;
10354 } else if (fstate == 3){
10355 BrHXXRatio = (myNPbase->BrHbbRatio());
10356 dBrHXXRatio1 = BrHXXRatio - 1.0;
10357 dBrHXXRatio2 = 0.0;
10358 } else if (fstate == 4){
10359 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10360 dBrHXXRatio1 = BrHXXRatio - 1.0;
10361 dBrHXXRatio2 = 0.0;
10362 } else {
10363 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10364 }
10365
10366 //-- Production x Decay:
10367 if ((this->getModel()).isModelLinearized()){
10368 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10369 } else if((this->getModel()).isModelNPquadratic()){
10370 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10371 } else {
10372 return weight*(muProd)*(BrHXXRatio);
10373 }
10374
10375
10376}
10377
10378
10379// -----------------------------------------------------------------------------
10380
10381STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10382: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10383{
10384 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10385 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10386
10387}
10388
10390{
10391 double BrHXXRatio = 1.0;
10392 if (fstate == 1){
10393 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10394 } else if (fstate == 2){
10395 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10396 } else if (fstate == 3){
10397 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10398 } else if (fstate == 4){
10399 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10400 } else {
10401 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10402 }
10403
10404 if ((this->getModel()).isModelLinearized()) {
10405 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10406 } else {
10407 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10408 }
10409}
10410
10411// -----------------------------------------------------------------------------
10412
10413//AG:STXS2024
10414STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10415: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10416{
10417 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10418 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10419
10420}
10421
10423{
10424 //-- Production:
10425 double weight = 1.0; //If normalized to the SM
10426 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10427 double muProd1 = muProd -1.0;
10428 double muProd2 = 0.0;
10429
10430 //-- Decay:
10431 double BrHXXRatio = 1.0;
10432 double dBrHXXRatio1 = 0.0;
10433 double dBrHXXRatio2 = 0.0;
10434 if (fstate==0){
10435 // Use for Cross-section [pb] with no Higgs-boson decay
10436 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10437 } else if (fstate == 1){
10438 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10439 dBrHXXRatio1 = BrHXXRatio - 1.0;
10440 dBrHXXRatio2 = 0.0;
10441 } else if (fstate == 2){
10442 BrHXXRatio = (myNPbase->BrHgagaRatio());
10443 dBrHXXRatio1 = BrHXXRatio - 1.0;
10444 dBrHXXRatio2 = 0.0;
10445 } else if (fstate == 3){
10446 BrHXXRatio = (myNPbase->BrHbbRatio());
10447 dBrHXXRatio1 = BrHXXRatio - 1.0;
10448 dBrHXXRatio2 = 0.0;
10449 } else if (fstate == 4){
10450 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10451 dBrHXXRatio1 = BrHXXRatio - 1.0;
10452 dBrHXXRatio2 = 0.0;
10453 } else {
10454 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10455 }
10456
10457 //-- Production x Decay:
10458 if ((this->getModel()).isModelLinearized()){
10459 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10460 } else if((this->getModel()).isModelNPquadratic()){
10461 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10462 } else {
10463 return weight*(muProd)*(BrHXXRatio);
10464 }
10465
10466
10467}
10468
10469// -----------------------------------------------------------------------------
10470
10471//AG:STXS2024
10472STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10473: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10474{
10475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10476 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10477
10478}
10479
10481{
10482 //-- Production:
10483 double weight = 1.0; //If normalized to the SM
10485 double muProd1 = muProd -1.0;
10486 double muProd2 = 0.0;
10487
10488 //-- Decay:
10489 double BrHXXRatio = 1.0;
10490 double dBrHXXRatio1 = 0.0;
10491 double dBrHXXRatio2 = 0.0;
10492 if (fstate==0){
10493 // Use for Cross-section [pb] with no Higgs-boson decay
10494 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10495 } else if (fstate == 1){
10496 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10497 dBrHXXRatio1 = BrHXXRatio - 1.0;
10498 dBrHXXRatio2 = 0.0;
10499 } else if (fstate == 2){
10500 BrHXXRatio = (myNPbase->BrHgagaRatio());
10501 dBrHXXRatio1 = BrHXXRatio - 1.0;
10502 dBrHXXRatio2 = 0.0;
10503 } else if (fstate == 3){
10504 BrHXXRatio = (myNPbase->BrHbbRatio());
10505 dBrHXXRatio1 = BrHXXRatio - 1.0;
10506 dBrHXXRatio2 = 0.0;
10507 } else if (fstate == 4){
10508 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10509 dBrHXXRatio1 = BrHXXRatio - 1.0;
10510 dBrHXXRatio2 = 0.0;
10511 } else {
10512 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10513 }
10514
10515 //-- Production x Decay:
10516 if ((this->getModel()).isModelLinearized()){
10517 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10518 } else if((this->getModel()).isModelNPquadratic()){
10519 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10520 } else {
10521 return weight*(muProd)*(BrHXXRatio);
10522 }
10523
10524}
10525
10526// -----------------------------------------------------------------------------
10527
10528STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10529: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10530{
10531 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10532 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10533
10534}
10535
10537{
10538 double BrHXXRatio = 1.0;
10539 if (fstate == 1){
10540 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10541 } else if (fstate == 2){
10542 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10543 } else if (fstate == 3){
10544 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10545 } else if (fstate == 4){
10546 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10547 } else {
10548 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10549 }
10550
10551 if ((this->getModel()).isModelLinearized()) {
10552 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10553 } else {
10554 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10555 }
10556}
10557
10558// -----------------------------------------------------------------------------
10559
10560STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10561: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10562{
10563 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10564 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10565
10566}
10567
10569{
10570 double BrHXXRatio = 1.0;
10571 if (fstate == 1){
10572 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10573 } else if (fstate == 2){
10574 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10575 } else if (fstate == 3){
10576 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10577 } else if (fstate == 4){
10578 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10579 } else {
10580 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10581 }
10582
10583 if ((this->getModel()).isModelLinearized()) {
10584 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10585 } else {
10586 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10587 }
10588}
10589
10590
10591// -----------------------------------------------------------------------------
10592
10593//AG:STXS2024
10594STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10595: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10596{
10597 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10598 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10599
10600}
10601
10603{
10604 //-- Production:
10605 double weight = 1.0; //If normalized to the SM
10606 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10607 double muProd1 = muProd -1.0;
10608 double muProd2 = 0.0;
10609
10610 //-- Decay:
10611 double BrHXXRatio = 1.0;
10612 double dBrHXXRatio1 = 0.0;
10613 double dBrHXXRatio2 = 0.0;
10614 if (fstate==0){
10615 // Use for Cross-section [pb] with no Higgs-boson decay
10616 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10617 } else if (fstate == 1){
10618 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10619 dBrHXXRatio1 = BrHXXRatio - 1.0;
10620 dBrHXXRatio2 = 0.0;
10621 } else if (fstate == 2){
10622 BrHXXRatio = (myNPbase->BrHgagaRatio());
10623 dBrHXXRatio1 = BrHXXRatio - 1.0;
10624 dBrHXXRatio2 = 0.0;
10625 } else if (fstate == 3){
10626 BrHXXRatio = (myNPbase->BrHbbRatio());
10627 dBrHXXRatio1 = BrHXXRatio - 1.0;
10628 dBrHXXRatio2 = 0.0;
10629 } else if (fstate == 4){
10630 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10631 dBrHXXRatio1 = BrHXXRatio - 1.0;
10632 dBrHXXRatio2 = 0.0;
10633 } else {
10634 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10635 }
10636
10637 //-- Production x Decay:
10638 if ((this->getModel()).isModelLinearized()){
10639 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10640 } else if((this->getModel()).isModelNPquadratic()){
10641 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10642 } else {
10643 return weight*(muProd)*(BrHXXRatio);
10644 }
10645
10646}
10647
10648// -----------------------------------------------------------------------------
10649
10650//AG:STXS2024
10651STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10652: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10653{
10654 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10655 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10656
10657}
10658
10660{
10661 //-- Production:
10662 double weight = 1.0; //If normalized to the SM
10663 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10664 double muProd1 = muProd -1.0;
10665 double muProd2 = 0.0;
10666
10667 //-- Decay:
10668 double BrHXXRatio = 1.0;
10669 double dBrHXXRatio1 = 0.0;
10670 double dBrHXXRatio2 = 0.0;
10671 if (fstate==0){
10672 // Use for Cross-section [pb] with no Higgs-boson decay
10673 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10674 } else if (fstate == 1){
10675 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10676 dBrHXXRatio1 = BrHXXRatio - 1.0;
10677 dBrHXXRatio2 = 0.0;
10678 } else if (fstate == 2){
10679 BrHXXRatio = (myNPbase->BrHgagaRatio());
10680 dBrHXXRatio1 = BrHXXRatio - 1.0;
10681 dBrHXXRatio2 = 0.0;
10682 } else if (fstate == 3){
10683 BrHXXRatio = (myNPbase->BrHbbRatio());
10684 dBrHXXRatio1 = BrHXXRatio - 1.0;
10685 dBrHXXRatio2 = 0.0;
10686 } else if (fstate == 4){
10687 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10688 dBrHXXRatio1 = BrHXXRatio - 1.0;
10689 dBrHXXRatio2 = 0.0;
10690 } else {
10691 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10692 }
10693
10694 //-- Production x Decay:
10695 if ((this->getModel()).isModelLinearized()){
10696 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10697 } else if((this->getModel()).isModelNPquadratic()){
10698 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10699 } else {
10700 return weight*(muProd)*(BrHXXRatio);
10701 }
10702
10703}
10704
10705// -----------------------------------------------------------------------------
10706
10707//AG:STXS2024
10708STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10709: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10710{
10711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10712 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10713
10714}
10715
10717{
10718 //-- Production:
10719 double weight = 1.0; //If normalized to the SM
10720 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10721 double muProd1 = muProd -1.0;
10722 double muProd2 = 0.0;
10723
10724 //-- Decay:
10725 double BrHXXRatio = 1.0;
10726 double dBrHXXRatio1 = 0.0;
10727 double dBrHXXRatio2 = 0.0;
10728 if (fstate==0){
10729 // Use for Cross-section [pb] with no Higgs-boson decay
10730 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10731 } else if (fstate == 1){
10732 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10733 dBrHXXRatio1 = BrHXXRatio - 1.0;
10734 dBrHXXRatio2 = 0.0;
10735 } else if (fstate == 2){
10736 BrHXXRatio = (myNPbase->BrHgagaRatio());
10737 dBrHXXRatio1 = BrHXXRatio - 1.0;
10738 dBrHXXRatio2 = 0.0;
10739 } else if (fstate == 3){
10740 BrHXXRatio = (myNPbase->BrHbbRatio());
10741 dBrHXXRatio1 = BrHXXRatio - 1.0;
10742 dBrHXXRatio2 = 0.0;
10743 } else if (fstate == 4){
10744 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10745 dBrHXXRatio1 = BrHXXRatio - 1.0;
10746 dBrHXXRatio2 = 0.0;
10747 } else {
10748 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10749 }
10750
10751 //-- Production x Decay:
10752 if ((this->getModel()).isModelLinearized()){
10753 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10754 } else if((this->getModel()).isModelNPquadratic()){
10755 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10756 } else {
10757 return weight*(muProd)*(BrHXXRatio);
10758 }
10759
10760
10761}
10762
10763// -----------------------------------------------------------------------------
10764
10765//AG:STXS2024
10766STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10767: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10768{
10769 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10770 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10771
10772}
10773
10775{
10776 //-- Production:
10777 double weight = 1.0; //If normalized to the SM
10778 //Since adding bins, include partial weigths of SM_predictions
10779 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10780 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10782 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10783 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10784 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10785 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10786 double muProd2 = 0.0;
10787
10788 //-- Decay:
10789 double BrHXXRatio = 1.0;
10790 double dBrHXXRatio1 = 0.0;
10791 double dBrHXXRatio2 = 0.0;
10792 if (fstate==0){
10793 weight = 1.0 ;
10794 } else if (fstate == 1){
10795 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10796 dBrHXXRatio1 = BrHXXRatio - 1.0;
10797 dBrHXXRatio2 = 0.0;
10798 } else if (fstate == 2){
10799 BrHXXRatio = (myNPbase->BrHgagaRatio());
10800 dBrHXXRatio1 = BrHXXRatio - 1.0;
10801 dBrHXXRatio2 = 0.0;
10802 } else if (fstate == 3){
10803 BrHXXRatio = (myNPbase->BrHbbRatio());
10804 dBrHXXRatio1 = BrHXXRatio - 1.0;
10805 dBrHXXRatio2 = 0.0;
10806 } else if (fstate == 4){
10807 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10808 dBrHXXRatio1 = BrHXXRatio - 1.0;
10809 dBrHXXRatio2 = 0.0;
10810 } else {
10811 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10812 }
10813
10814 //-- Production x Decay:
10815 if ((this->getModel()).isModelLinearized()){
10816 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10817 } else if((this->getModel()).isModelNPquadratic()){
10818 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10819 } else {
10820 return weight*(muProd)*(BrHXXRatio);
10821 }
10822
10823
10824}
10825
10826// -----------------------------------------------------------------------------
10827
10828//AG:STXS2024
10829STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10830: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10831{
10832 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10833 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10834
10835}
10836
10838{
10839 //-- Production:
10840 double weight = 1.0; //If normalized to the SM
10841 //Since adding bins, include partial weigths of SM_predictions
10842 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10843 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10852 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10853 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10854 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10856 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10857 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10858 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10860 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10861 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10862 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10863 double muProd2 = 0.0;
10864
10865 //-- Decay:
10866 double BrHXXRatio = 1.0;
10867 double dBrHXXRatio1 = 0.0;
10868 double dBrHXXRatio2 = 0.0;
10869 if (fstate==0){
10870 weight = 1.0;
10871 } else if (fstate == 1){
10872 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10873 dBrHXXRatio1 = BrHXXRatio - 1.0;
10874 dBrHXXRatio2 = 0.0;
10875 } else if (fstate == 2){
10876 BrHXXRatio = (myNPbase->BrHgagaRatio());
10877 dBrHXXRatio1 = BrHXXRatio - 1.0;
10878 dBrHXXRatio2 = 0.0;
10879 } else if (fstate == 3){
10880 BrHXXRatio = (myNPbase->BrHbbRatio());
10881 dBrHXXRatio1 = BrHXXRatio - 1.0;
10882 dBrHXXRatio2 = 0.0;
10883 } else if (fstate == 4){
10884 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10885 dBrHXXRatio1 = BrHXXRatio - 1.0;
10886 dBrHXXRatio2 = 0.0;
10887 } else if (fstate == 5){
10888 BrHXXRatio = (myNPbase->BrHtautauRatio());
10889 dBrHXXRatio1 = BrHXXRatio - 1.0;
10890 dBrHXXRatio2 = 0.0;
10891 } else if (fstate == 6){
10892 BrHXXRatio = (myNPbase->BrHWWRatio());
10893 dBrHXXRatio1 = BrHXXRatio - 1.0;
10894 dBrHXXRatio2 = 0.0;
10895 } else if (fstate == 7){
10896 BrHXXRatio = (myNPbase->BrHZZRatio());
10897 dBrHXXRatio1 = BrHXXRatio - 1.0;
10898 dBrHXXRatio2 = 0.0;
10899 } else {
10900 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10901 }
10902
10903 //-- Production x Decay:
10904 if ((this->getModel()).isModelLinearized()){
10905 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10906 } else if((this->getModel()).isModelNPquadratic()){
10907 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10908 } else {
10909 return weight*(muProd)*(BrHXXRatio);
10910 }
10911
10912
10913}
10914
10915// -----------------------------------------------------------------------------
10916
10917//AG:STXS2024
10918STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10919: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10920{
10921 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10922 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
10923
10924}
10925
10927{
10928 //-- Production:
10929 double weight = 1.0; //If normalized to the SM
10930 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
10931 double muProd1 = muProd -1.0;
10932 double muProd2 = 0.0;
10933
10934 //-- Decay:
10935 double BrHXXRatio = 1.0;
10936 double dBrHXXRatio1 = 0.0;
10937 double dBrHXXRatio2 = 0.0;
10938 if (fstate==0){
10939 // Use for Cross-section [pb] with no Higgs-boson decay
10940 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10941 } else if (fstate == 1){
10942 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10943 dBrHXXRatio1 = BrHXXRatio - 1.0;
10944 dBrHXXRatio2 = 0.0;
10945 } else if (fstate == 2){
10946 BrHXXRatio = (myNPbase->BrHgagaRatio());
10947 dBrHXXRatio1 = BrHXXRatio - 1.0;
10948 dBrHXXRatio2 = 0.0;
10949 } else if (fstate == 3){
10950 BrHXXRatio = (myNPbase->BrHbbRatio());
10951 dBrHXXRatio1 = BrHXXRatio - 1.0;
10952 dBrHXXRatio2 = 0.0;
10953 } else if (fstate == 4){
10954 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10955 dBrHXXRatio1 = BrHXXRatio - 1.0;
10956 dBrHXXRatio2 = 0.0;
10957 } else {
10958 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
10959 }
10960
10961 //-- Production x Decay:
10962 if ((this->getModel()).isModelLinearized()){
10963 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10964 } else if((this->getModel()).isModelNPquadratic()){
10965 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10966 } else {
10967 return weight*(muProd)*(BrHXXRatio);
10968 }
10969
10970
10971}
10972
10973// -----------------------------------------------------------------------------
10974
10975//AG:STXS2024
10976STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10977: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10978{
10979 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10980 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
10981
10982}
10983
10985{
10986 //-- Production:
10987 double weight = 1.0; //If normalized to the SM
10988 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
10989 double muProd1 = muProd -1.0;
10990 double muProd2 = 0.0;
10991
10992 //-- Decay:
10993 double BrHXXRatio = 1.0;
10994 double dBrHXXRatio1 = 0.0;
10995 double dBrHXXRatio2 = 0.0;
10996 if (fstate==0){
10997 // Use for Cross-section [pb] with no Higgs-boson decay
10998 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10999 } else if (fstate == 1){
11000 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11001 dBrHXXRatio1 = BrHXXRatio - 1.0;
11002 dBrHXXRatio2 = 0.0;
11003 } else if (fstate == 2){
11004 BrHXXRatio = (myNPbase->BrHgagaRatio());
11005 dBrHXXRatio1 = BrHXXRatio - 1.0;
11006 dBrHXXRatio2 = 0.0;
11007 } else if (fstate == 3){
11008 BrHXXRatio = (myNPbase->BrHbbRatio());
11009 dBrHXXRatio1 = BrHXXRatio - 1.0;
11010 dBrHXXRatio2 = 0.0;
11011 } else if (fstate == 4){
11012 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11013 dBrHXXRatio1 = BrHXXRatio - 1.0;
11014 dBrHXXRatio2 = 0.0;
11015 } else {
11016 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
11017 }
11018
11019 //-- Production x Decay:
11020 if ((this->getModel()).isModelLinearized()){
11021 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11022 } else if((this->getModel()).isModelNPquadratic()){
11023 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11024 } else {
11025 return weight*(muProd)*(BrHXXRatio);
11026 }
11027
11028}
11029
11030// -----------------------------------------------------------------------------
11031
11032//AG:STXS2024
11033STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11034: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11035{
11036 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11037 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
11038
11039}
11040
11042{
11043 //-- Production:
11044 double weight = 1.0; //If normalized to the SM
11045 //Since adding bins, include partial weigths of SM_predictions
11046 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11047 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
11048 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
11049 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
11050 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
11051 double muProd2 = 0.0;
11052
11053 //-- Decay:
11054 double BrHXXRatio = 1.0;
11055 double dBrHXXRatio1 = 0.0;
11056 double dBrHXXRatio2 = 0.0;
11057 if (fstate==0){
11058 // Use for Cross-section [pb] with no Higgs-boson decay
11059 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11060 } else if (fstate == 1){
11061 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11062 dBrHXXRatio1 = BrHXXRatio - 1.0;
11063 dBrHXXRatio2 = 0.0;
11064 } else if (fstate == 2){
11065 BrHXXRatio = (myNPbase->BrHgagaRatio());
11066 dBrHXXRatio1 = BrHXXRatio - 1.0;
11067 dBrHXXRatio2 = 0.0;
11068 } else if (fstate == 3){
11069 BrHXXRatio = (myNPbase->BrHbbRatio());
11070 dBrHXXRatio1 = BrHXXRatio - 1.0;
11071 dBrHXXRatio2 = 0.0;
11072 } else if (fstate == 4){
11073 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11074 dBrHXXRatio1 = BrHXXRatio - 1.0;
11075 dBrHXXRatio2 = 0.0;
11076 } else {
11077 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
11078 }
11079
11080 //-- Production x Decay:
11081 if ((this->getModel()).isModelLinearized()){
11082 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11083 } else if((this->getModel()).isModelNPquadratic()){
11084 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11085 } else {
11086 return weight*(muProd)*(BrHXXRatio);
11087 }
11088
11089}
11090
11091// -----------------------------------------------------------------------------
11092
11093//AG:STXS2024
11094STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11095: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11096{
11097 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11098 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
11099
11100}
11101
11103{
11104 //-- Production:
11105 double weight = 1.0; //If normalized to the SM
11106 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
11107 double muProd1 = muProd -1.0;
11108 double muProd2 = 0.0;
11109
11110 //-- Decay:
11111 double BrHXXRatio = 1.0;
11112 double dBrHXXRatio1 = 0.0;
11113 double dBrHXXRatio2 = 0.0;
11114 if (fstate==0){
11115 // Use for Cross-section [pb] with no Higgs-boson decay
11116 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11117 } else if (fstate == 1){
11118 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11119 dBrHXXRatio1 = BrHXXRatio - 1.0;
11120 dBrHXXRatio2 = 0.0;
11121 } else if (fstate == 2){
11122 BrHXXRatio = (myNPbase->BrHgagaRatio());
11123 dBrHXXRatio1 = BrHXXRatio - 1.0;
11124 dBrHXXRatio2 = 0.0;
11125 } else if (fstate == 3){
11126 BrHXXRatio = (myNPbase->BrHbbRatio());
11127 dBrHXXRatio1 = BrHXXRatio - 1.0;
11128 dBrHXXRatio2 = 0.0;
11129 } else if (fstate == 4){
11130 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11131 dBrHXXRatio1 = BrHXXRatio - 1.0;
11132 dBrHXXRatio2 = 0.0;
11133 } else {
11134 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
11135 }
11136
11137 //-- Production x Decay:
11138 if ((this->getModel()).isModelLinearized()){
11139 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11140 } else if((this->getModel()).isModelNPquadratic()){
11141 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11142 } else {
11143 return weight*(muProd)*(BrHXXRatio);
11144 }
11145
11146}
11147
11148// -----------------------------------------------------------------------------
11149
11150//AG:STXS2024
11151STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11152: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11153{
11154 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11155 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
11156
11157}
11158
11160{
11161 //-- Production:
11162 double weight = 1.0; //If normalized to the SM
11163 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
11164 double muProd1 = muProd -1.0;
11165 double muProd2 = 0.0;
11166
11167 //-- Decay:
11168 double BrHXXRatio = 1.0;
11169 double dBrHXXRatio1 = 0.0;
11170 double dBrHXXRatio2 = 0.0;
11171 if (fstate==0){
11172 // Use for Cross-section [pb] with no Higgs-boson decay
11173 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11174 } else if (fstate == 1){
11175 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11176 dBrHXXRatio1 = BrHXXRatio - 1.0;
11177 dBrHXXRatio2 = 0.0;
11178 } else if (fstate == 2){
11179 BrHXXRatio = (myNPbase->BrHgagaRatio());
11180 dBrHXXRatio1 = BrHXXRatio - 1.0;
11181 dBrHXXRatio2 = 0.0;
11182 } else if (fstate == 3){
11183 BrHXXRatio = (myNPbase->BrHbbRatio());
11184 dBrHXXRatio1 = BrHXXRatio - 1.0;
11185 dBrHXXRatio2 = 0.0;
11186 } else if (fstate == 4){
11187 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11188 dBrHXXRatio1 = BrHXXRatio - 1.0;
11189 dBrHXXRatio2 = 0.0;
11190 } else {
11191 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
11192 }
11193
11194 //-- Production x Decay:
11195 if ((this->getModel()).isModelLinearized()){
11196 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11197 } else if((this->getModel()).isModelNPquadratic()){
11198 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11199 } else {
11200 return weight*(muProd)*(BrHXXRatio);
11201 }
11202
11203}
11204
11205// -----------------------------------------------------------------------------
11206
11207STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11208: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11209{
11210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11211 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
11212
11213}
11214
11216{
11217 //-- Production:
11218 double weight = 1.0; //If normalized to the SM
11219 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
11220 double muProd1 = muProd -1.0;
11221 double muProd2 = 0.0;
11222
11223 //-- Decay:
11224 double BrHXXRatio = 1.0;
11225 double dBrHXXRatio1 = 0.0;
11226 double dBrHXXRatio2 = 0.0;
11227 if (fstate==0){
11228 // Use for Cross-section [pb] with no Higgs-boson decay
11229 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11230 } else if (fstate == 1){
11231 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11232 dBrHXXRatio1 = BrHXXRatio - 1.0;
11233 dBrHXXRatio2 = 0.0;
11234 } else if (fstate == 2){
11235 BrHXXRatio = (myNPbase->BrHgagaRatio());
11236 dBrHXXRatio1 = BrHXXRatio - 1.0;
11237 dBrHXXRatio2 = 0.0;
11238 } else if (fstate == 3){
11239 BrHXXRatio = (myNPbase->BrHbbRatio());
11240 dBrHXXRatio1 = BrHXXRatio - 1.0;
11241 dBrHXXRatio2 = 0.0;
11242 } else if (fstate == 4){
11243 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11244 dBrHXXRatio1 = BrHXXRatio - 1.0;
11245 dBrHXXRatio2 = 0.0;
11246 } else {
11247 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
11248 }
11249
11250 //-- Production x Decay:
11251 if ((this->getModel()).isModelLinearized()){
11252 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11253 } else if((this->getModel()).isModelNPquadratic()){
11254 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11255 } else {
11256 return weight*(muProd)*(BrHXXRatio);
11257 }
11258
11259
11260}
11261
11262// -----------------------------------------------------------------------------
11263
11264//AG:STXS2024
11265STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11266: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11267{
11268 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11269 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11270
11271}
11272
11274{
11275 //-- Production:
11276 double weight = 1.0; //If normalized to the SM
11277 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11278 double muProd1 = muProd -1.0;
11279 double muProd2 = 0.0;
11280
11281 //-- Decay:
11282 double BrHXXRatio = 1.0;
11283 double dBrHXXRatio1 = 0.0;
11284 double dBrHXXRatio2 = 0.0;
11285 if (fstate==0){
11286 // Use for Cross-section [pb] with no Higgs-boson decay
11287 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11288 } else if (fstate == 1){
11289 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11290 dBrHXXRatio1 = BrHXXRatio - 1.0;
11291 dBrHXXRatio2 = 0.0;
11292 } else if (fstate == 2){
11293 BrHXXRatio = (myNPbase->BrHgagaRatio());
11294 dBrHXXRatio1 = BrHXXRatio - 1.0;
11295 dBrHXXRatio2 = 0.0;
11296 } else if (fstate == 3){
11297 BrHXXRatio = (myNPbase->BrHbbRatio());
11298 dBrHXXRatio1 = BrHXXRatio - 1.0;
11299 dBrHXXRatio2 = 0.0;
11300 } else if (fstate == 4){
11301 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11302 dBrHXXRatio1 = BrHXXRatio - 1.0;
11303 dBrHXXRatio2 = 0.0;
11304 } else if (fstate == 5){
11305 BrHXXRatio = (myNPbase->BrHtautauRatio());
11306 dBrHXXRatio1 = BrHXXRatio - 1.0;
11307 dBrHXXRatio2 = 0.0;
11308 } else {
11309 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11310 }
11311
11312 //-- Production x Decay:
11313 if ((this->getModel()).isModelLinearized()){
11314 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11315 } else if((this->getModel()).isModelNPquadratic()){
11316 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11317 } else {
11318 return weight*(muProd)*(BrHXXRatio);
11319 }
11320
11321}
11322// -----------------------------------------------------------------------------
11323
11324//AG:STXS2024
11325STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11326: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11327{
11328 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11329 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11330
11331}
11332
11334{
11335 //-- Production:
11336 double weight = 1.0; //If normalized to the SM
11337 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11338 double muProd1 = muProd -1.0;
11339 double muProd2 = 0.0;
11340
11341 //-- Decay:
11342 double BrHXXRatio = 1.0;
11343 double dBrHXXRatio1 = 0.0;
11344 double dBrHXXRatio2 = 0.0;
11345 if (fstate==0){
11346 // Use for Cross-section [pb] with no Higgs-boson decay
11347 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11348 } else if (fstate == 1){
11349 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11350 dBrHXXRatio1 = BrHXXRatio - 1.0;
11351 dBrHXXRatio2 = 0.0;
11352 } else if (fstate == 2){
11353 BrHXXRatio = (myNPbase->BrHgagaRatio());
11354 dBrHXXRatio1 = BrHXXRatio - 1.0;
11355 dBrHXXRatio2 = 0.0;
11356 } else if (fstate == 3){
11357 BrHXXRatio = (myNPbase->BrHbbRatio());
11358 dBrHXXRatio1 = BrHXXRatio - 1.0;
11359 dBrHXXRatio2 = 0.0;
11360 } else if (fstate == 4){
11361 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11362 dBrHXXRatio1 = BrHXXRatio - 1.0;
11363 dBrHXXRatio2 = 0.0;
11364 } else if (fstate == 5){
11365 BrHXXRatio = (myNPbase->BrHtautauRatio());
11366 dBrHXXRatio1 = BrHXXRatio - 1.0;
11367 dBrHXXRatio2 = 0.0;
11368 } else {
11369 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11370 }
11371
11372 //-- Production x Decay:
11373 if ((this->getModel()).isModelLinearized()){
11374 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11375 } else if((this->getModel()).isModelNPquadratic()){
11376 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11377 } else {
11378 return weight*(muProd)*(BrHXXRatio);
11379 }
11380
11381}
11382
11383// -----------------------------------------------------------------------------
11384
11385//AG:STXS2024
11386STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11387: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11388{
11389 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11390 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11391
11392}
11393
11395{
11396 //-- Production:
11397 double weight = 1.0; //If normalized to the SM
11398 //Since adding bins, include partial weigths of SM_predictions
11399 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11400 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11401 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11402 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11403 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11404 double muProd2 = 0.0;
11405
11406 //-- Decay:
11407 double BrHXXRatio = 1.0;
11408 double dBrHXXRatio1 = 0.0;
11409 double dBrHXXRatio2 = 0.0;
11410 if (fstate==0){
11411 // Use for Cross-section [pb] with no Higgs-boson decay
11412 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11413 } else if (fstate == 1){
11414 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11415 dBrHXXRatio1 = BrHXXRatio - 1.0;
11416 dBrHXXRatio2 = 0.0;
11417 } else if (fstate == 2){
11418 BrHXXRatio = (myNPbase->BrHgagaRatio());
11419 dBrHXXRatio1 = BrHXXRatio - 1.0;
11420 dBrHXXRatio2 = 0.0;
11421 } else if (fstate == 3){
11422 BrHXXRatio = (myNPbase->BrHbbRatio());
11423 dBrHXXRatio1 = BrHXXRatio - 1.0;
11424 dBrHXXRatio2 = 0.0;
11425 } else if (fstate == 4){
11426 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11427 dBrHXXRatio1 = BrHXXRatio - 1.0;
11428 dBrHXXRatio2 = 0.0;
11429 } else if (fstate == 5){
11430 BrHXXRatio = (myNPbase->BrHtautauRatio());
11431 dBrHXXRatio1 = BrHXXRatio - 1.0;
11432 dBrHXXRatio2 = 0.0;
11433 } else {
11434 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11435 }
11436
11437 //-- Production x Decay:
11438 if ((this->getModel()).isModelLinearized()){
11439 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11440 } else if((this->getModel()).isModelNPquadratic()){
11441 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11442 } else {
11443 return weight*(muProd)*(BrHXXRatio);
11444 }
11445
11446}
11447
11448// -----------------------------------------------------------------------------
11449
11450//AG:STXS2024
11451STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11452: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11453{
11454 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11455 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11456
11457}
11458
11460{
11461 //-- Production:
11462 double weight = 1.0; //If normalized to the SM
11463 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11464 //Since adding bins, include partial weigths (SM_predictions)
11465 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11470 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11471 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11472 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11473 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11474 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11475 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11476 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11477 double muProd2 = 0.0;
11478
11479 //-- Decay:
11480 double BrHXXRatio = 1.0;
11481 double dBrHXXRatio1 = 0.0;
11482 double dBrHXXRatio2 = 0.0;
11483 if (fstate==0){
11484 weight = 1.0;
11485 } else if (fstate == 1){
11486 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11487 dBrHXXRatio1 = BrHXXRatio - 1.0;
11488 dBrHXXRatio2 = 0.0;
11489 } else if (fstate == 2){
11490 BrHXXRatio = (myNPbase->BrHgagaRatio());
11491 dBrHXXRatio1 = BrHXXRatio - 1.0;
11492 dBrHXXRatio2 = 0.0;
11493 } else if (fstate == 3){
11494 BrHXXRatio = (myNPbase->BrHbbRatio());
11495 dBrHXXRatio1 = BrHXXRatio - 1.0;
11496 dBrHXXRatio2 = 0.0;
11497 } else if (fstate == 4){
11498 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11499 dBrHXXRatio1 = BrHXXRatio - 1.0;
11500 dBrHXXRatio2 = 0.0;
11501 } else if (fstate == 5){
11502 BrHXXRatio = (myNPbase->BrHtautauRatio());
11503 dBrHXXRatio1 = BrHXXRatio - 1.0;
11504 dBrHXXRatio2 = 0.0;
11505 } else if (fstate == 6){
11506 BrHXXRatio = (myNPbase->BrHWWRatio());
11507 dBrHXXRatio1 = BrHXXRatio - 1.0;
11508 dBrHXXRatio2 = 0.0;
11509 } else if (fstate == 7){
11510 BrHXXRatio = (myNPbase->BrHZZRatio());
11511 dBrHXXRatio1 = BrHXXRatio - 1.0;
11512 dBrHXXRatio2 = 0.0;
11513 } else {
11514 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11515 }
11516
11517 //-- Production x Decay:
11518 if ((this->getModel()).isModelLinearized()){
11519 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11520 } else if((this->getModel()).isModelNPquadratic()){
11521 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11522 } else {
11523 return weight*(muProd)*(BrHXXRatio);
11524 }
11525
11526}
11527
11528// -----------------------------------------------------------------------------
11529
11530//AG:STXS2024
11531STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11532: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11533{
11534 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11535 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11536
11537}
11538
11539double STXS12_tH::computeThValue() //AG:modified
11540{
11541 //-- Production:
11542 double weight = 1.0; //If normalized to the SM
11543 double muProd = myNPbase->STXS12_tH(sqrt_s);
11544 double muProd1 = muProd -1.0;
11545 double muProd2 = 0.0;
11546
11547 //-- Decay:
11548 double BrHXXRatio = 1.0;
11549 double dBrHXXRatio1 = 0.0;
11550 double dBrHXXRatio2 = 0.0;
11551 if (fstate==0){
11552 // Use for Cross-section [pb] with no Higgs-boson decay
11553 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11554 } else if (fstate == 1){
11555 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11556 dBrHXXRatio1 = BrHXXRatio - 1.0;
11557 dBrHXXRatio2 = 0.0;
11558 } else if (fstate == 2){
11559 BrHXXRatio = (myNPbase->BrHgagaRatio());
11560 dBrHXXRatio1 = BrHXXRatio - 1.0;
11561 dBrHXXRatio2 = 0.0;
11562 } else if (fstate == 3){
11563 BrHXXRatio = (myNPbase->BrHbbRatio());
11564 dBrHXXRatio1 = BrHXXRatio - 1.0;
11565 dBrHXXRatio2 = 0.0;
11566 } else if (fstate == 4){
11567 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11568 dBrHXXRatio1 = BrHXXRatio - 1.0;
11569 dBrHXXRatio2 = 0.0;
11570 } else if (fstate == 5){
11571 BrHXXRatio = (myNPbase->BrHtautauRatio());
11572 dBrHXXRatio1 = BrHXXRatio - 1.0;
11573 dBrHXXRatio2 = 0.0;
11574 } else {
11575 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11576 }
11577
11578 //-- Production x Decay:
11579 if ((this->getModel()).isModelLinearized()){
11580 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11581 } else if((this->getModel()).isModelNPquadratic()){
11582 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11583 } else {
11584 return weight*(muProd)*(BrHXXRatio);
11585 }
11586
11587
11588}
11589
11590// -----------------------------------------------------------------------------
11591
11592
11593//-----------------------------------------------------------------------------------------
11594//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11595//-----------------------------------------------------------------------------------------
11596
11597
11598muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11599: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11600{
11601 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11602 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11603}
11604
11606{
11607 return myNPbase->muTHUggHgaga(sqrt_s);
11608}
11609
11610
11611muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11612: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11613{
11614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11615 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11616}
11617
11619{
11620 return myNPbase->muTHUVBFHgaga(sqrt_s);
11621}
11622
11623muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11624: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11625{
11626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11627 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11628}
11629
11631{
11632 return myNPbase->muTHUZHgaga(sqrt_s);
11633}
11634
11635muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11636: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11637{
11638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11639 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11640}
11641
11643{
11644 return myNPbase->muTHUWHgaga(sqrt_s);
11645}
11646
11647muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11648: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11649{
11650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11651 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11652}
11653
11655{
11656 return myNPbase->muTHUVHgaga(sqrt_s);
11657}
11658
11659muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11660: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11661{
11662 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11663 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11664}
11665
11667{
11668 return myNPbase->muTHUttHgaga(sqrt_s);
11669}
11670
11671muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11672: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11673{
11674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11675 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11676}
11677
11679{
11680 return myNPbase->muTHUggHZga(sqrt_s);
11681}
11682
11683muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11684: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11685{
11686 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11687 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11688}
11689
11691{
11692 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11693}
11694
11695muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11696: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11697{
11698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11699 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11700}
11701
11703{
11704
11705 return myNPbase->muTHUVBFHZga(sqrt_s);
11706}
11707
11708muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11709: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11710{
11711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11712 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11713}
11714
11716{
11717 return myNPbase->muTHUZHZga(sqrt_s);
11718}
11719
11720muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11721: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11722{
11723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11724 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11725}
11726
11728{
11729 return myNPbase->muTHUWHZga(sqrt_s);
11730}
11731
11732muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11733: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11734{
11735 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11736 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11737}
11738
11740{
11741 return myNPbase->muTHUVHZga(sqrt_s);
11742}
11743
11744muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11745: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11746{
11747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11748 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11749}
11750
11752{
11753 return myNPbase->muTHUttHZga(sqrt_s);
11754}
11755
11756muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11757: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11758{
11759 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11760 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11761}
11762
11764{
11765 return myNPbase->muTHUggHZZ(sqrt_s);
11766}
11767
11768muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11769: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11770{
11771 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11772 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11773}
11774
11776{
11777 return myNPbase->muTHUVBFHZZ(sqrt_s);
11778}
11779
11780muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11781: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11782{
11783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11784 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11785}
11786
11788{
11789 return myNPbase->muTHUZHZZ(sqrt_s);
11790}
11791
11792muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11793: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11794{
11795 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11796 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11797}
11798
11800{
11801 return myNPbase->muTHUWHZZ(sqrt_s);
11802}
11803
11804muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11805: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11806{
11807 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11808 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11809}
11810
11812{
11813 return myNPbase->muTHUVHZZ(sqrt_s);
11814}
11815
11816muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11817: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11818{
11819 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11820 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11821}
11822
11824{
11825 return myNPbase->muTHUttHZZ(sqrt_s);
11826}
11827
11828muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11829: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11830{
11831 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11832 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11833}
11834
11836{
11837 return myNPbase->muTHUggHZZ4l(sqrt_s);
11838}
11839
11840muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11841: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11842{
11843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11844 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11845}
11846
11848{
11849 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11850}
11851
11852muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11853: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11854{
11855 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11856 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11857}
11858
11860{
11861 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11862}
11863
11864muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11865: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11866{
11867 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11868 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11869}
11870
11872{
11873 return myNPbase->muTHUZHZZ4l(sqrt_s);
11874}
11875
11876muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11877: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11878{
11879 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11880 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11881}
11882
11884{
11885 return myNPbase->muTHUWHZZ4l(sqrt_s);
11886}
11887
11888muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11889: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11890{
11891 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11892 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11893}
11894
11896{
11897 return myNPbase->muTHUVHZZ4l(sqrt_s);
11898}
11899
11900muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11901: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11902{
11903 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11904 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11905}
11906
11908{
11909 return myNPbase->muTHUttHZZ4l(sqrt_s);
11910}
11911
11912muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11913: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11914{
11915 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11916 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11917}
11918
11920{
11921 return myNPbase->muTHUggHWW(sqrt_s);
11922}
11923
11924muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
11925: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11926{
11927 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11928 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
11929}
11930
11932{
11933 return myNPbase->muTHUVBFHWW(sqrt_s);
11934}
11935
11936muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
11937: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11938{
11939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11940 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
11941}
11942
11944{
11945 return myNPbase->muTHUZHWW(sqrt_s);
11946}
11947
11948muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
11949: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11950{
11951 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11952 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
11953}
11954
11956{
11957 return myNPbase->muTHUWHWW(sqrt_s);
11958}
11959
11960muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
11961: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11962{
11963 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11964 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
11965}
11966
11968{
11969 return myNPbase->muTHUVHWW(sqrt_s);
11970}
11971
11972muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
11973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11974{
11975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11976 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
11977}
11978
11980{
11981 return myNPbase->muTHUttHWW(sqrt_s);
11982}
11983
11984muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11986{
11987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11988 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
11989}
11990
11992{
11994}
11995
11996muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11997: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11998{
11999 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12000 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
12001}
12002
12004{
12006}
12007
12008muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12009: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12010{
12011 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12012 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
12013}
12014
12016{
12017 return myNPbase->muTHUZHWW2l2v(sqrt_s);
12018}
12019
12020muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12022{
12023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12024 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
12025}
12026
12028{
12029 return myNPbase->muTHUWHWW2l2v(sqrt_s);
12030}
12031
12032muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12033: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12034{
12035 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12036 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
12037}
12038
12040{
12041 return myNPbase->muTHUVHWW2l2v(sqrt_s);
12042}
12043
12044muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12045: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12046{
12047 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12048 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
12049}
12050
12052{
12054}
12055
12056muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12057: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12058{
12059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12060 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
12061}
12062
12064{
12065 return myNPbase->muTHUggHmumu(sqrt_s);
12066}
12067
12068muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12069: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12070{
12071 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12072 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
12073}
12074
12076{
12077 return myNPbase->muTHUVBFHmumu(sqrt_s);
12078}
12079
12080muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12081: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12082{
12083 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12084 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
12085}
12086
12088{
12089 return myNPbase->muTHUZHmumu(sqrt_s);
12090}
12091
12092muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12093: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12094{
12095 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12096 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
12097}
12098
12100{
12101 return myNPbase->muTHUWHmumu(sqrt_s);
12102}
12103
12104muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12105: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12106{
12107 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12108 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
12109}
12110
12112{
12113 return myNPbase->muTHUVHmumu(sqrt_s);
12114}
12115
12116muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12118{
12119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12120 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
12121}
12122
12124{
12125 return myNPbase->muTHUttHmumu(sqrt_s);
12126}
12127
12128muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12129: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12130{
12131 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12132 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
12133}
12134
12136{
12138}
12139
12140muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12141: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12142{
12143 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12144 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
12145}
12146
12148{
12150}
12151
12152muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12153: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12154{
12155 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12156 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
12157}
12158
12160{
12161 return myNPbase->muTHUZHtautau(sqrt_s);
12162}
12163
12164muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12166{
12167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12168 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
12169}
12170
12172{
12173 return myNPbase->muTHUWHtautau(sqrt_s);
12174}
12175
12176muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12177: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12178{
12179 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12180 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
12181}
12182
12184{
12185 return myNPbase->muTHUVHtautau(sqrt_s);
12186}
12187
12188muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12189: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12190{
12191 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12192 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
12193}
12194
12196{
12198}
12199
12200muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
12201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12202{
12203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12204 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
12205}
12206
12208{
12209 return myNPbase->muTHUggHbb(sqrt_s);
12210}
12211
12212muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
12213: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12214{
12215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12216 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
12217}
12218
12220{
12221 return myNPbase->muTHUVBFHbb(sqrt_s);
12222}
12223
12224muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
12225: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12226{
12227 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12228 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
12229}
12230
12232{
12233 return myNPbase->muTHUZHbb(sqrt_s);
12234}
12235
12236muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
12237: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12238{
12239 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12240 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
12241}
12242
12244{
12245 return myNPbase->muTHUWHbb(sqrt_s);
12246}
12247
12248muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
12249: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12250{
12251 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12252 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
12253}
12254
12256{
12257 return myNPbase->muTHUVHbb(sqrt_s);
12258}
12259
12260muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
12261: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12262{
12263 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12264 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
12265}
12266
12268{
12269 return myNPbase->muTHUttHbb(sqrt_s);
12270}
12271
12272
12273muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12274: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12275{
12276 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12277 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12278}
12279
12281{
12282
12283 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12284
12285}
12286
12287muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12288: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12289{
12290 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12291 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12292}
12293
12295{
12296
12297 return (myNPbase->muTHUVBFHinv(sqrt_s));
12298
12299}
12300
12301
12302muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12303: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12304{
12305 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12306 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12307}
12308
12310{
12311
12312 return (myNPbase->muTHUVHBRinv(sqrt_s));
12313
12314}
12315
12316muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12317: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12318{
12319 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12320 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12321}
12322
12324{
12325 return (myNPbase->muTHUVHinv(sqrt_s));
12326}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1839
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1763
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3994
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3599
virtual const double cbminuscc() const
Definition: NPbase.h:2788
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:2974
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4269
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:2020
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4359
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2461
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1162
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3890
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2938
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2864
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2569
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:3034
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4005
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1634
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3379
virtual const double cVpluscb() const
Definition: NPbase.h:2770
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:2024
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3899
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1383
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1743
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1137
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4066
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4152
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3984
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3425
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1943
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1418
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:1113
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2211
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4098
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1523
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1212
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3474
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1559
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2129
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1710
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1650
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1811
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2876
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3628
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1779
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4251
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3776
virtual const double ccminusctau() const
Definition: NPbase.h:2806
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2888
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4143
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3504
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1775
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4386
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1690
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1916
virtual const double cgaplusct() const
Definition: NPbase.h:2752
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:3039
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2848
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:2006
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1246
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1767
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3416
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4368
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:4088
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2201
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1463
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4107
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:3049
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1939
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2828
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2868
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2872
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3785
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4048
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1799
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2149
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4161
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4197
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2942
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3454
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4224
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1666
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2918
virtual const double cgplusct() const
Definition: NPbase.h:2743
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1831
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3739
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2844
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1475
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:3022
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4017
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1723
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1731
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4305
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1638
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1751
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:2038
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1281
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3872
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3752
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4188
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3712
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2362
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2326
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2304
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1576
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1871
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1332
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3812
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1594
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3608
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2221
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:1997
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3794
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:2011
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4260
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4296
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3667
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3618
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:3026
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3648
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2909
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1875
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:3054
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2648
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1934
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1642
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:2015
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3398
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1755
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1739
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1678
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4413
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:1993
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1966
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2836
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3494
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1662
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2056
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1885
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3638
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1257
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1894
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3935
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1975
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2934
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3703
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2076
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2191
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3513
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1646
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:3010
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1803
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1686
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2958
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1488
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1295
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3803
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2066
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2698
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2840
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2578
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3369
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1771
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1175
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1747
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1835
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4422
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1851
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:2042
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4039
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3590
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1759
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4030
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3962
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3685
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3721
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1819
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2824
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1988
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2930
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1984
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1582
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2954
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3926
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1345
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3840
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2294
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1930
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1618
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2734
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2599
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3522
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1622
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3760
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3550
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2668
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4431
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2171
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3944
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1694
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1499
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1511
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3434
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3973
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2251
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1847
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4116
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1187
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3407
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2707
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:2970
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3917
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4314
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:3059
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2159
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3953
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:3002
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2897
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1727
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4125
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4170
virtual const double cbminusctau() const
Definition: NPbase.h:2797
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2630
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1407
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2139
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2371
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1150
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2913
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1702
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2716
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2962
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4057
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1200
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3908
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2086
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2096
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2659
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1588
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1855
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1735
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2884
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:1102
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3464
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1571
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3484
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2905
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3676
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1979
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1823
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:2990
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2109
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3851
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4206
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2231
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3694
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2515
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:3044
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1843
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2119
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2819
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1859
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4377
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2893
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1630
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:3014
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2832
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1783
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1670
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1682
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:2002
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1235
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4449
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1674
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2678
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1807
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1791
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3863
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1658
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2621
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2922
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4233
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3570
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4332
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2688
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3768
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2284
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1815
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:3030
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1371
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1395
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1898
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3389
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:4077
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4341
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1451
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:3064
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3444
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3830
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1535
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4242
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1827
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2608
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2470
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1654
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:2998
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2264
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1614
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4134
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3881
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2725
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2852
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2181
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2946
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2241
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1307
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1912
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1787
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3658
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:2982
virtual const double cgminuscga() const
Definition: NPbase.h:2761
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3357
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1889
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2880
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4179
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:3006
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1268
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1879
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3541
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3560
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:1125
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1609
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2639
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:1091
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1970
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4440
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double cVplusctau() const
Definition: NPbase.h:2779
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2950
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3730
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1224
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1903
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:2994
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1719
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4323
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1907
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1863
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1706
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2856
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1429
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4395
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1358
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:3018
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:2978
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4278
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1319
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3580
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2901
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4350
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1795
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1626
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1867
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:2986
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4404
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3532
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:2966
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1698
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3821
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2926
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1547
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4215
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2860
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase